Fix VFS layer:
authorAlexander Bokovoy <ab@samba.org>
Sun, 11 May 2003 23:34:18 +0000 (23:34 +0000)
committerAlexander Bokovoy <ab@samba.org>
Sun, 11 May 2003 23:34:18 +0000 (23:34 +0000)
1. Finally work with cascaded modules with private data storage per module
2. Convert VFS API to macro calls to simplify cascading
3. Add quota support to VFS layer (prepare to NT quota support)

Patch by Stefan (metze) Metzemacher, with review of Jelmer and me
Tested in past few weeks. Documentation to new VFS API for third-party developers to follow

34 files changed:
source/include/includes.h
source/include/smb.h
source/include/smb_macros.h
source/include/vfs.h
source/locking/posix.c
source/modules/vfs_audit.c
source/modules/vfs_extd_audit.c
source/modules/vfs_fake_perms.c
source/modules/vfs_netatalk.c
source/modules/vfs_recycle.c
source/msdfs/msdfs.c
source/param/loadparm.c
source/printing/nt_printing.c
source/printing/printfsp.c
source/rpc_server/srv_srvsvc_nt.c
source/smbd/close.c
source/smbd/conn.c
source/smbd/dir.c
source/smbd/dosmode.c
source/smbd/fileio.c
source/smbd/filename.c
source/smbd/notify_hash.c
source/smbd/nttrans.c
source/smbd/open.c
source/smbd/posix_acls.c
source/smbd/reply.c
source/smbd/service.c
source/smbd/statcache.c
source/smbd/trans2.c
source/smbd/vfs-wrap.c
source/smbd/vfs.c
source/torture/cmd_vfs.c
source/torture/vfstest.c
source/torture/vfstest.h

index 9e4c508477b1aa41db29f9e4445c1c8ff76d05e4..c1b84c1d3568115dbc957f7c70da4f2493f43450 100644 (file)
@@ -767,6 +767,7 @@ extern int errno;
 #include "debugparse.h"
 
 #include "version.h"
+#include "idmap.h"
 #include "smb.h"
 #include "smbw.h"
 #include "nameserv.h"
index 8595dfa1b19ec83848c32872456c548a6adb3142..fc5c50323049898d5e7410e98f7d7c9fcea7a1a9 100644 (file)
@@ -259,7 +259,7 @@ enum SID_NAME_USE
  *
  * @sa http://msdn.microsoft.com/library/default.asp?url=/library/en-us/security/accctrl_38yn.asp
  **/
-typedef struct sid_info
+typedef struct DOM_SID
 {
   uint8  sid_rev_num;             /**< SID revision number */
   uint8  num_auths;               /**< Number of sub-authorities */
@@ -406,6 +406,7 @@ typedef struct files_struct
 } files_struct;
 
 #include "ntquotas.h"
+#include "sysquotas.h"
 
 /* used to hold an arbitrary blob of data */
 typedef struct data_blob {
@@ -441,18 +442,10 @@ typedef struct
 #include "smb_acls.h"
 #include "vfs.h"
 
-typedef struct smb_vfs_handle_struct
-{
-    void *data;
-    /* Handle on dlopen() call */
-    void *handle;
-    struct smb_vfs_handle_struct  *next, *prev;
-    
-} smb_vfs_handle_struct;
-
 typedef struct connection_struct
 {
        struct connection_struct *next, *prev;
+       TALLOC_CTX *mem_ctx;
        unsigned cnum; /* an index passed over the wire */
        int service;
        BOOL force_user;
@@ -467,8 +460,9 @@ typedef struct connection_struct
        char *connectpath;
        char *origpath;
 
-       struct vfs_ops vfs_ops;                   /* Filesystem operations */
-       struct smb_vfs_handle_struct *vfs_private;
+       struct vfs_ops vfs;                   /* Filesystem operations */
+       struct vfs_ops vfs_opaque;                      /* OPAQUE Filesystem operations */
+       struct vfs_handle_struct *vfs_handles;          /* for the new plugins */
 
        char *user; /* name of user who *opened* this connection */
        uid_t uid; /* uid of user who *opened* this connection */
index b39c7a0ebcec7b768003a182f892a9eaf7fa4169..aae3b46f7a4b11f821522b034b7ee86154b00cf7 100644 (file)
@@ -247,52 +247,4 @@ copy an IP address from one buffer to another
 
 #define dos_format(fname) string_replace(fname,'/','\\')
 
-/*******************************************************************
- vfs stat wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_stat(conn, fname, st) ((conn)->vfs_ops.stat((conn), fname,(st)))
-
-/*******************************************************************
- vfs lstat wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_lstat(conn, fname, st) ((conn)->vfs_ops.lstat((conn), fname,(st)))
-
-/*******************************************************************
- vfs fstat wrapper
-********************************************************************/
-
-#define vfs_fstat(fsp, fd, st) ((fsp)->conn->vfs_ops.fstat((fsp),(fd),(st)))
-
-/*******************************************************************
- vfs rmdir wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_rmdir(conn,fname) ((conn)->vfs_ops.rmdir((conn),fname))
-
-/*******************************************************************
- vfs Unlink wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_unlink(conn, fname) ((conn)->vfs_ops.unlink((conn),fname))
-
-/*******************************************************************
- vfs chmod wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_chmod(conn,fname,mode) ((conn)->vfs_ops.chmod((conn),fname,(mode)))
-
-/*******************************************************************
- vfs chown wrapper that calls internal2unix.
-********************************************************************/
-
-#define vfs_chown(conn,fname,uid,gid) ((conn)->vfs_ops.chown((conn),fname,(uid),(gid)))
-
-/*******************************************************************
- A wrapper for vfs_chdir().
-********************************************************************/
-
-#define vfs_chdir(conn,fname) ((conn)->vfs_ops.chdir((conn),fname))
-
 #endif /* _SMB_MACROS_H */
index 756e417814d0e2bff70833245aafbc4d1c734d2f..852e926e6da4a48b75a2624365b9c65bd13e0bf8 100644 (file)
@@ -3,6 +3,7 @@
    VFS structures and parameters
    Copyright (C) Tim Potter                            1999
    Copyright (C) Alexander Bokovoy                     2002
+   Copyright (C) Stefan (metze) Metzmacher             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
 /* Changed to version 3 for POSIX acl extensions. JRA. */
 /* Changed to version 4 for cascaded VFS interface. Alexander Bokovoy. */
 /* Changed to version 5 for sendfile addition. JRA. */
-#define SMB_VFS_INTERFACE_VERSION 5
+/* Changed to version 6 for the new module system, fixed cascading and quota functions. --metze */
+#define SMB_VFS_INTERFACE_VERSION 6
 
 
-/* Version of supported cascaded interface backward compatibility.
-   (version 5 corresponds to SMB_VFS_INTERFACE_VERSION 5)
-   It is used in vfs_init_custom() to detect VFS modules which conform to cascaded 
-   VFS interface but implement elder version than current version of Samba uses.
-   This allows to use old modules with new VFS interface as far as combined VFS operation
-   set is coherent (will be in most cases). 
-*/
-#define SMB_VFS_INTERFACE_CASCADED 5
+/* to bug old modules witch are trying to compile with the old functions */
+#define vfs_init __ERROR_please_port_this_module_to_SMB_VFS_INTERFACE_VERSION_6(void) { __ERROR_please_port_this_module_to_SMB_VFS_INTERFACE_VERSION_6 };
+#define lp_parm_string __ERROR_please_port_lp_parm_string_to_lp_parm_const_string_or_lp_parm_talloc_string { \
+  __ERROR_please_port_lp_parm_string_to_lp_parm_const_string_or_lp_parm_talloc_string };
+#define lp_vfs_options __ERROR_please_donot_use_lp_vfs_options_anymore_use_lp_parm_xxxx_functions_instead { \
+  __ERROR_please_donot_use_lp_vfs_options_anymore_use_lp_parm_xxxx_functions_instead };
 
 /*
-    Each VFS module must provide following global functions:
-    vfs_init   -- initialization function
-    vfs_done   -- finalization function
-    
-    vfs_init must return proper initialized vfs_op_tuple[] array
-    which describes all operations this module claims to intercept. This function
-    is called whenever module is loaded into smbd process using sys_dlopen().
-    
-    vfs_init must store somewhere vfs_handle reference if module wants to store per-instance
-    private information for further usage. vfs_handle->data should be used to
-    store such information. Do not try to change other fields in this structure
-    or results likely to be unpredictable.
-    
-    vfs_done must perform finalization of the module. In particular,
-    this function must free vfs_ops structure returned to module from smb_vfs_get_opaque_ops()
-    function if it is used (see below). This function is called whenever module 
-    is unloaded from smbd process using sys_dlclose().
-    
-    Prototypes:
-    vfs_op_tuple *vfs_init(const struct vfs_ops *def_vfs_ops,
-                           struct smb_vfs_handle_struct *vfs_handle);
-    void         vfs_done(connection_struct *conn);
-    
     All intercepted VFS operations must be declared as static functions inside module source
-    in order to keep smbd namespace unpolluted. See source of skel, audit, and recycle bin
+    in order to keep smbd namespace unpolluted. See source of audit, extd_audit, fake_perms and recycle
     example VFS modules for more details.
-    
 */
 
 /* VFS operations structure */
 
+struct vfs_handle_struct;
 struct connection_struct;
 struct files_struct;
 struct security_descriptor_info;
 
-struct vfs_ops {
-
-       /* Disk operations */
-    
-       int (*connect)(struct connection_struct *conn, const char *service, const char *user);
-       void (*disconnect)(struct connection_struct *conn);
-       SMB_BIG_UINT (*disk_free)(struct connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize, 
-               SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
-    
-       /* Directory operations */
-
-       DIR *(*opendir)(struct connection_struct *conn, const char *fname);
-       struct dirent *(*readdir)(struct connection_struct *conn, DIR *dirp);
-       int (*mkdir)(struct connection_struct *conn, const char *path, mode_t mode);
-       int (*rmdir)(struct connection_struct *conn, const char *path);
-       int (*closedir)(struct connection_struct *conn, DIR *dir);
-    
-       /* File operations */
-    
-       int (*open)(struct connection_struct *conn, const char *fname, int flags, mode_t mode);
-       int (*close)(struct files_struct *fsp, int fd);
-       ssize_t (*read)(struct files_struct *fsp, int fd, void *data, size_t n);
-       ssize_t (*write)(struct files_struct *fsp, int fd, const void *data, size_t n);
-       SMB_OFF_T (*lseek)(struct files_struct *fsp, int filedes, SMB_OFF_T offset, int whence);
-       ssize_t (*sendfile)(int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
-       int (*rename)(struct connection_struct *conn, const char *old, const char *new);
-       int (*fsync)(struct files_struct *fsp, int fd);
-       int (*stat)(struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf);
-       int (*fstat)(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf);
-       int (*lstat)(struct connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf);
-       int (*unlink)(struct connection_struct *conn, const char *path);
-       int (*chmod)(struct connection_struct *conn, const char *path, mode_t mode);
-       int (*fchmod)(struct files_struct *fsp, int fd, mode_t mode);
-       int (*chown)(struct connection_struct *conn, const char *path, uid_t uid, gid_t gid);
-       int (*fchown)(struct files_struct *fsp, int fd, uid_t uid, gid_t gid);
-       int (*chdir)(struct connection_struct *conn, const char *path);
-       char *(*getwd)(struct connection_struct *conn, char *buf);
-       int (*utime)(struct connection_struct *conn, const char *path, struct utimbuf *times);
-       int (*ftruncate)(struct files_struct *fsp, int fd, SMB_OFF_T offset);
-       BOOL (*lock)(struct files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
-       int (*symlink)(struct connection_struct *conn, const char *oldpath, const char *newpath);
-       int (*readlink)(struct connection_struct *conn, const char *path, char *buf, size_t bufsiz);
-       int (*link)(struct connection_struct *conn, const char *oldpath, const char *newpath);
-       int (*mknod)(struct connection_struct *conn, const char *path, mode_t mode, SMB_DEV_T dev);
-       char *(*realpath)(struct connection_struct *conn, const char *path, char *resolved_path);
-
-       /* NT ACL operations. */
-
-       size_t (*fget_nt_acl)(struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc);
-       size_t (*get_nt_acl)(struct files_struct *fsp, const char *name, struct security_descriptor_info **ppdesc);
-       BOOL (*fset_nt_acl)(struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd);
-       BOOL (*set_nt_acl)(struct files_struct *fsp, const char *name, uint32 security_info_sent, struct security_descriptor_info *psd);
-
-       /* POSIX ACL operations. */
-
-       int (*chmod_acl)(struct connection_struct *conn, const char *name, mode_t mode);
-       int (*fchmod_acl)(struct files_struct *fsp, int fd, mode_t mode);
-
-       int (*sys_acl_get_entry)(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
-       int (*sys_acl_get_tag_type)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
-       int (*sys_acl_get_permset)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
-       void * (*sys_acl_get_qualifier)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d);
-       SMB_ACL_T (*sys_acl_get_file)(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type);
-       SMB_ACL_T (*sys_acl_get_fd)(struct files_struct *fsp, int fd);
-       int (*sys_acl_clear_perms)(struct connection_struct *conn, SMB_ACL_PERMSET_T permset);
-       int (*sys_acl_add_perm)(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-       char * (*sys_acl_to_text)(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen);
-       SMB_ACL_T (*sys_acl_init)(struct connection_struct *conn, int count);
-       int (*sys_acl_create_entry)(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
-       int (*sys_acl_set_tag_type)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
-       int (*sys_acl_set_qualifier)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual);
-       int (*sys_acl_set_permset)(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
-       int (*sys_acl_valid)(struct connection_struct *conn, SMB_ACL_T theacl );
-       int (*sys_acl_set_file)(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
-       int (*sys_acl_set_fd)(struct files_struct *fsp, int fd, SMB_ACL_T theacl);
-       int (*sys_acl_delete_def_file)(struct connection_struct *conn, const char *path);
-       int (*sys_acl_get_perm)(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
-       int (*sys_acl_free_text)(struct connection_struct *conn, char *text);
-       int (*sys_acl_free_acl)(struct connection_struct *conn, SMB_ACL_T posix_acl);
-       int (*sys_acl_free_qualifier)(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype);
-};
-
-struct vfs_options {
-    struct vfs_options *prev, *next;
-    char *name;
-    char *value;
-};
-
 /*
-    Available VFS operations. These values must be in sync with vfs_ops struct.
+    Available VFS operations. These values must be in sync with vfs_ops struct
+    (struct vfs_fn_pointers and struct vfs_handle_pointers inside of struct vfs_ops). 
     In particular, if new operations are added to vfs_ops, appropriate constants
     should be added to vfs_op_type so that order of them kept same as in vfs_ops.
 */
 
 typedef enum _vfs_op_type {
-
        SMB_VFS_OP_NOOP = -1,
        
        /* Disk operations */
@@ -196,6 +85,8 @@ typedef enum _vfs_op_type {
        SMB_VFS_OP_CONNECT = 0,
        SMB_VFS_OP_DISCONNECT,
        SMB_VFS_OP_DISK_FREE,
+       SMB_VFS_OP_GET_QUOTA,
+       SMB_VFS_OP_SET_QUOTA,
 
        /* Directory operations */
 
@@ -274,6 +165,176 @@ typedef enum _vfs_op_type {
        SMB_VFS_OP_LAST
 } vfs_op_type;
 
+/*
+    Please keep vfs_op_type, struct vfs_fn_pointers and struct vfs_handles_pointers in sync.
+*/
+struct vfs_ops {
+       struct vfs_fn_pointers {
+               /* Disk operations */
+               
+               int (*connect)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *service, const char *user);
+               void (*disconnect)(struct vfs_handle_struct *handle, struct connection_struct *conn);
+               SMB_BIG_UINT (*disk_free)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize, 
+                       SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
+               int (*get_quota)(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt);
+               int (*set_quota)(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt);
+               
+               /* Directory operations */
+               
+               DIR *(*opendir)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *fname);
+               struct dirent *(*readdir)(struct vfs_handle_struct *handle, struct connection_struct *conn, DIR *dirp);
+               int (*mkdir)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, mode_t mode);
+               int (*rmdir)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path);
+               int (*closedir)(struct vfs_handle_struct *handle, struct connection_struct *conn, DIR *dir);
+               
+               /* File operations */
+               
+               int (*open)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *fname, int flags, mode_t mode);
+               int (*close)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd);
+               ssize_t (*read)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, void *data, size_t n);
+               ssize_t (*write)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, const void *data, size_t n);
+               SMB_OFF_T (*lseek)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_OFF_T offset, int whence);
+               ssize_t (*sendfile)(struct vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *header, SMB_OFF_T offset, size_t count);
+               int (*rename)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *old, const char *new);
+               int (*fsync)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd);
+               int (*stat)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf);
+               int (*fstat)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf);
+               int (*lstat)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf);
+               int (*unlink)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path);
+               int (*chmod)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, mode_t mode);
+               int (*fchmod)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, mode_t mode);
+               int (*chown)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, uid_t uid, gid_t gid);
+               int (*fchown)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, uid_t uid, gid_t gid);
+               int (*chdir)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path);
+               char *(*getwd)(struct vfs_handle_struct *handle, struct connection_struct *conn, char *buf);
+               int (*utime)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, struct utimbuf *times);
+               int (*ftruncate)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_OFF_T offset);
+               BOOL (*lock)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type);
+               int (*symlink)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *oldpath, const char *newpath);
+               int (*readlink)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, char *buf, size_t bufsiz);
+               int (*link)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *oldpath, const char *newpath);
+               int (*mknod)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, mode_t mode, SMB_DEV_T dev);
+               char *(*realpath)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, char *resolved_path);
+               
+               /* NT ACL operations. */
+               
+               size_t (*fget_nt_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc);
+               size_t (*get_nt_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, struct security_descriptor_info **ppdesc);
+               BOOL (*fset_nt_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd);
+               BOOL (*set_nt_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, uint32 security_info_sent, struct security_descriptor_info *psd);
+               
+               /* POSIX ACL operations. */
+               
+               int (*chmod_acl)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *name, mode_t mode);
+               int (*fchmod_acl)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, mode_t mode);
+               
+               int (*sys_acl_get_entry)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p);
+               int (*sys_acl_get_tag_type)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p);
+               int (*sys_acl_get_permset)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p);
+               void * (*sys_acl_get_qualifier)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d);
+               SMB_ACL_T (*sys_acl_get_file)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type);
+               SMB_ACL_T (*sys_acl_get_fd)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd);
+               int (*sys_acl_clear_perms)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_PERMSET_T permset);
+               int (*sys_acl_add_perm)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+               char * (*sys_acl_to_text)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen);
+               SMB_ACL_T (*sys_acl_init)(struct vfs_handle_struct *handle, struct connection_struct *conn, int count);
+               int (*sys_acl_create_entry)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry);
+               int (*sys_acl_set_tag_type)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype);
+               int (*sys_acl_set_qualifier)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual);
+               int (*sys_acl_set_permset)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset);
+               int (*sys_acl_valid)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_T theacl );
+               int (*sys_acl_set_file)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl);
+               int (*sys_acl_set_fd)(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_ACL_T theacl);
+               int (*sys_acl_delete_def_file)(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path);
+               int (*sys_acl_get_perm)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm);
+               int (*sys_acl_free_text)(struct vfs_handle_struct *handle, struct connection_struct *conn, char *text);
+               int (*sys_acl_free_acl)(struct vfs_handle_struct *handle, struct connection_struct *conn, SMB_ACL_T posix_acl);
+               int (*sys_acl_free_qualifier)(struct vfs_handle_struct *handle, struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype);
+       } ops;
+
+       struct vfs_handles_pointers {
+               /* Disk operations */
+
+               struct vfs_handle_struct *connect;
+               struct vfs_handle_struct *disconnect;
+               struct vfs_handle_struct *disk_free;
+               struct vfs_handle_struct *get_quota;
+               struct vfs_handle_struct *set_quota;
+
+               /* Directory operations */
+
+               struct vfs_handle_struct *opendir;
+               struct vfs_handle_struct *readdir;
+               struct vfs_handle_struct *mkdir;
+               struct vfs_handle_struct *rmdir;
+               struct vfs_handle_struct *closedir;
+
+               /* File operations */
+
+               struct vfs_handle_struct *open;
+               struct vfs_handle_struct *close;
+               struct vfs_handle_struct *read;
+               struct vfs_handle_struct *write;
+               struct vfs_handle_struct *lseek;
+               struct vfs_handle_struct *sendfile;
+               struct vfs_handle_struct *rename;
+               struct vfs_handle_struct *fsync;
+               struct vfs_handle_struct *stat;
+               struct vfs_handle_struct *fstat;
+               struct vfs_handle_struct *lstat;
+               struct vfs_handle_struct *unlink;
+               struct vfs_handle_struct *chmod;
+               struct vfs_handle_struct *fchmod;
+               struct vfs_handle_struct *chown;
+               struct vfs_handle_struct *fchown;
+               struct vfs_handle_struct *chdir;
+               struct vfs_handle_struct *getwd;
+               struct vfs_handle_struct *utime;
+               struct vfs_handle_struct *ftruncate;
+               struct vfs_handle_struct *lock;
+               struct vfs_handle_struct *symlink;
+               struct vfs_handle_struct *readlink;
+               struct vfs_handle_struct *link;
+               struct vfs_handle_struct *mknod;
+               struct vfs_handle_struct *realpath;
+
+               /* NT ACL operations. */
+
+               struct vfs_handle_struct *fget_nt_acl;
+               struct vfs_handle_struct *get_nt_acl;
+               struct vfs_handle_struct *fset_nt_acl;
+               struct vfs_handle_struct *set_nt_acl;
+
+               /* POSIX ACL operations. */
+
+               struct vfs_handle_struct *chmod_acl;
+               struct vfs_handle_struct *fchmod_acl;
+
+               struct vfs_handle_struct *sys_acl_get_entry;
+               struct vfs_handle_struct *sys_acl_get_tag_type;
+               struct vfs_handle_struct *sys_acl_get_permset;
+               struct vfs_handle_struct *sys_acl_get_qualifier;
+               struct vfs_handle_struct *sys_acl_get_file;
+               struct vfs_handle_struct *sys_acl_get_fd;
+               struct vfs_handle_struct *sys_acl_clear_perms;
+               struct vfs_handle_struct *sys_acl_add_perm;
+               struct vfs_handle_struct *sys_acl_to_text;
+               struct vfs_handle_struct *sys_acl_init;
+               struct vfs_handle_struct *sys_acl_create_entry;
+               struct vfs_handle_struct *sys_acl_set_tag_type;
+               struct vfs_handle_struct *sys_acl_set_qualifier;
+               struct vfs_handle_struct *sys_acl_set_permset;
+               struct vfs_handle_struct *sys_acl_valid;
+               struct vfs_handle_struct *sys_acl_set_file;
+               struct vfs_handle_struct *sys_acl_set_fd;
+               struct vfs_handle_struct *sys_acl_delete_def_file;
+               struct vfs_handle_struct *sys_acl_get_perm;
+               struct vfs_handle_struct *sys_acl_free_text;
+               struct vfs_handle_struct *sys_acl_free_acl;
+               struct vfs_handle_struct *sys_acl_free_qualifier;
+       } handles;
+};
+
 /*
     Possible VFS operation layers (per-operation)
     
@@ -300,7 +361,7 @@ typedef enum _vfs_op_layer {
        SMB_VFS_LAYER_OPAQUE = 0,       /* - Final level, does not call anything beyond itself */
        SMB_VFS_LAYER_TRANSPARENT,      /* - Normal operation, calls underlying layer after */
                                        /*   possibly changing passed data */
-       SMB_VFS_LAYER_LOGGER,           /* - Logs data, calls underlying layer, logging does not */
+       SMB_VFS_LAYER_LOGGER,           /* - Logs data, calls underlying layer, logging may not */
                                        /*   use Samba VFS */
        SMB_VFS_LAYER_SPLITTER,         /* - Splits operation, calls underlying layer _and_ own facility, */
                                        /*   then combines result */
@@ -309,10 +370,10 @@ typedef enum _vfs_op_layer {
 } vfs_op_layer;
 
 /*
-    VFS operation description. Each VFS module initialization function returns to VFS subsystem 
-    an array of vfs_op_tuple which describes all operations this module is willing to intercept. 
-    VFS subsystem initializes then vfs_ops using this information and passes it 
-    to next VFS module as underlying vfs_ops and to connection after all VFS modules are initialized.
+    VFS operation description. Each VFS module registers an array of vfs_op_tuple to VFS subsystem,
+    which describes all operations this module is willing to intercept. 
+    VFS subsystem initializes then the conn->vfs_ops and conn->vfs_opaque_ops structs
+    using this information.
 */
 
 typedef struct _vfs_op_tuple {
@@ -321,18 +382,46 @@ typedef struct _vfs_op_tuple {
        vfs_op_layer layer;
 } vfs_op_tuple;
 
-/*
-    Return vfs_ops filled with current opaque VFS operations. This function is designed to
-    be called from VFS module initialization function for those modules which needs 'direct' VFS
-    access (loggers or initiators of file operations other than connection asks for).
-    
-    Returned vfs_ops must be cleaned up in VFS module's finalizer function (vfs_done_<module_name>)
-    using safe_free().
-    
-    Prototype:
-    struct vfs_ops *smb_vfs_get_opaque_ops();
-    
-    This prototype will be available via include/proto.h
-*/
+
+typedef struct vfs_handle_struct {
+       struct vfs_handle_struct  *next, *prev;
+       const char *param;
+       struct vfs_ops vfs_next;
+       struct connection_struct *conn;
+       void *data;
+       void (*free_data)(void **data);
+} vfs_handle_struct;
+
+
+#define VFS_HANDLE_GET_DATA(handle, datap, type, ret) { \
+       if (!(handle)||((datap=(type *)(handle)->data)==NULL)) { \
+               DEBUG(0,("%s() failed to get vfs_handle->data!\n",FUNCTION_MACRO)); \
+               ret; \
+       } \
+}
+
+#define VFS_HANDLE_SET_DATA(handle, datap, free_fn, type, ret) { \
+       if (!(handle)) { \
+               DEBUG(0,("%s() failed to set handle->data!\n",FUNCTION_MACRO)); \
+               ret; \
+       } else { \
+               if ((handle)->free_data) { \
+                       (handle)->free_data(&(handle)->data); \
+               } \
+               (handle)->data = (void *)datap; \
+               (handle)->free_data = free_fn; \
+       } \
+}
+
+#define VFS_HANDLE_FREE_DATA(handle) { \
+       if ((handle) && (handle)->free_data) { \
+               (handle)->free_data(&(handle)->data); \
+       } \
+}
+
+#define VFS_OP(x) ((void *) x)
+
+
+#include "vfs_macros.h"
 
 #endif /* _VFS_H */
index 2b64631d39afb629283027b10fdbc0ccfe78dd33..1c794a1c86d6a7bdf1176d3cbb815430d527cfc2 100644 (file)
@@ -205,7 +205,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
                /*
                 * No POSIX to worry about, just close.
                 */
-               ret = conn->vfs_ops.close(fsp,fsp->fd);
+               ret = VFS_CLOSE(fsp,fsp->fd);
                fsp->fd = -1;
                return ret;
        }
@@ -259,7 +259,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
                DEBUG(10,("fd_close_posix: doing close on %u fd's.\n", (unsigned int)count ));
 
                for(i = 0; i < count; i++) {
-                       if (conn->vfs_ops.close(fsp,fd_array[i]) == -1) {
+                       if (VFS_CLOSE(fsp,fd_array[i]) == -1) {
                                saved_errno = errno;
                        }
                }
@@ -278,7 +278,7 @@ int fd_close_posix(struct connection_struct *conn, files_struct *fsp)
         * Finally close the fd associated with this fsp.
         */
 
-       ret = conn->vfs_ops.close(fsp,fsp->fd);
+       ret = VFS_CLOSE(fsp,fsp->fd);
 
        if (saved_errno != 0) {
         errno = saved_errno;
@@ -646,11 +646,10 @@ static BOOL posix_lock_in_range(SMB_OFF_T *offset_out, SMB_OFF_T *count_out,
 static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 {
        int ret;
-       struct connection_struct *conn = fsp->conn;
 
        DEBUG(8,("posix_fcntl_lock %d %d %.0f %.0f %d\n",fsp->fd,op,(double)offset,(double)count,type));
 
-       ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
+       ret = VFS_LOCK(fsp,fsp->fd,op,offset,count,type);
 
        if (!ret && ((errno == EFBIG) || (errno == ENOLCK) || (errno ==  EINVAL))) {
 
@@ -674,7 +673,7 @@ static BOOL posix_fcntl_lock(files_struct *fsp, int op, SMB_OFF_T offset, SMB_OF
                        DEBUG(0,("Count greater than 31 bits - retrying with 31 bit truncated length.\n"));
                        errno = 0;
                        count &= 0x7fffffff;
-                       ret = conn->vfs_ops.lock(fsp,fsp->fd,op,offset,count,type);
+                       ret = VFS_LOCK(fsp,fsp->fd,op,offset,count,type);
                }
        }
 
index 4f9dc1b1e400fe7dde5b42e3e7ff23f314c04a66..ccb2d47fc4bcc6fd4716f9b38a10d57baaf9a9a0 100644 (file)
@@ -2,8 +2,9 @@
  * 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) Tim Potter                    1999-2000
+ * Copyright (C) Alexander Bokovoy             2002
+ * Copyright (C) Stefan (metze) Metzmacher     2002
  *
  * 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
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include "config.h"
-#include <stdio.h>
-#include <sys/stat.h>
-#ifdef HAVE_UTIME_H
-#include <utime.h>
-#endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-#include <syslog.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#include <errno.h>
-#include <string.h>
-#include <includes.h>
-#include <vfs.h>
-
-#ifndef SYSLOG_FACILITY
-#define SYSLOG_FACILITY   LOG_USER
-#endif
-
-#ifndef SYSLOG_PRIORITY
-#define SYSLOG_PRIORITY   LOG_NOTICE
-#endif
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
 
 /* Function prototypes */
 
-static int audit_connect(struct connection_struct *conn, const char *svc, const char *user);
-static void audit_disconnect(struct connection_struct *conn);
-static DIR *audit_opendir(struct connection_struct *conn, const char *fname);
-static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t mode);
-static int audit_rmdir(struct connection_struct *conn, const char *path);
-static int audit_open(struct connection_struct *conn, const char *fname, int flags, mode_t mode);
-static int audit_close(struct files_struct *fsp, int fd);
-static int audit_rename(struct connection_struct *conn, const char *old, const char *new);
-static int audit_unlink(struct connection_struct *conn, const char *path);
-static int audit_chmod(struct connection_struct *conn, const char *path, mode_t mode);
-static int audit_chmod_acl(struct connection_struct *conn, const char *name, mode_t mode);
-static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode);
-static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode);
+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 DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname);
+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_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 int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new);
+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_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode);
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode);
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode);
 
 /* VFS operations */
 
-static struct vfs_ops default_vfs_ops;   /* For passthrough operation */
-static struct smb_vfs_handle_struct *audit_handle;
-
-static vfs_op_tuple audit_ops[] = {
+static vfs_op_tuple audit_op_tuples[] = {
     
        /* Disk operations */
 
-       {audit_connect,         SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_LOGGER},
-       {audit_disconnect,      SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_connect),         SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_disconnect),      SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_LOGGER},
 
        /* Directory operations */
 
-       {audit_opendir,         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_LOGGER},
-       {audit_mkdir,           SMB_VFS_OP_MKDIR,       SMB_VFS_LAYER_LOGGER},
-       {audit_rmdir,           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_opendir),         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_mkdir),           SMB_VFS_OP_MKDIR,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_rmdir),           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_LOGGER},
 
        /* File operations */
 
-       {audit_open,            SMB_VFS_OP_OPEN,        SMB_VFS_LAYER_LOGGER},
-       {audit_close,           SMB_VFS_OP_CLOSE,       SMB_VFS_LAYER_LOGGER},
-       {audit_rename,          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_LOGGER},
-       {audit_unlink,          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_LOGGER},
-       {audit_chmod,           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_LOGGER},
-       {audit_fchmod,          SMB_VFS_OP_FCHMOD,      SMB_VFS_LAYER_LOGGER},
-       {audit_chmod_acl,       SMB_VFS_OP_CHMOD_ACL,   SMB_VFS_LAYER_LOGGER},
-       {audit_fchmod_acl,      SMB_VFS_OP_FCHMOD_ACL,  SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_open),            SMB_VFS_OP_OPEN,        SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_close),           SMB_VFS_OP_CLOSE,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_rename),          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_unlink),          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_chmod),           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_fchmod),          SMB_VFS_OP_FCHMOD,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_chmod_acl),       SMB_VFS_OP_CHMOD_ACL,   SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_fchmod_acl),      SMB_VFS_OP_FCHMOD_ACL,  SMB_VFS_LAYER_LOGGER},
        
        /* Finish VFS operations definition */
        
-       {NULL,                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
+       {VFS_OP(NULL),                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 };
 
-/* VFS initialisation function.  Return vfs_op_tuple array back to SAMBA. */
 
-static vfs_op_tuple *audit_init(const struct vfs_ops *def_vfs_ops, 
-                       struct smb_vfs_handle_struct *vfs_handle)
+static int audit_syslog_facility(vfs_handle_struct *handle)
 {
-       memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
-       
-       audit_handle = vfs_handle;
+       /* fix me: let this be configurable by:
+        *      lp_param_enum(SNUM(handle->conn),(handle->param?handle->param:"audit"),"syslog facility",
+        *              audit_enum_facility,LOG_USER); 
+        */
+       return LOG_USER;
+}
 
-       openlog("smbd_audit", LOG_PID, SYSLOG_FACILITY);
-       syslog(SYSLOG_PRIORITY, "VFS_INIT: vfs_ops loaded\n");
-       return audit_ops;
+
+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:"audit"),"syslog priority",
+        *              audit_enum_priority,LOG_NOTICE); 
+        */
+       return LOG_NOTICE;
 }
 
 /* Implementation of vfs_ops.  Pass everything on to the default
    operation but log event first. */
 
-static int audit_connect(struct connection_struct *conn, const char *svc, const char *user)
+static int audit_connect(vfs_handle_struct *handle, connection_struct *conn, const char *svc, const char *user)
 {
-       syslog(SYSLOG_PRIORITY, "connect to service %s by user %s\n", 
+       int result;
+       
+       openlog("smbd_audit", LOG_PID, audit_syslog_facility(handle));
+
+       syslog(audit_syslog_priority(handle), "connect to service %s by user %s\n", 
               svc, user);
 
-       return default_vfs_ops.connect(conn, svc, user);
+       result = VFS_NEXT_CONNECT(handle, conn, svc, user);
+
+       return result;
 }
 
-static void audit_disconnect(struct connection_struct *conn)
+static void audit_disconnect(vfs_handle_struct *handle, connection_struct *conn)
 {
-       syslog(SYSLOG_PRIORITY, "disconnected\n");
-       default_vfs_ops.disconnect(conn);
+       syslog(audit_syslog_priority(handle), "disconnected\n");
+       VFS_NEXT_DISCONNECT(handle, conn);
+
+       return;
 }
 
-static DIR *audit_opendir(struct connection_struct *conn, const char *fname)
+static DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname)
 {
-       DIR *result = default_vfs_ops.opendir(conn, fname);
+       DIR *result;
+       
+       result = VFS_NEXT_OPENDIR(handle, conn, fname);
 
-       syslog(SYSLOG_PRIORITY, "opendir %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "opendir %s %s%s\n",
               fname,
               (result == NULL) ? "failed: " : "",
               (result == NULL) ? strerror(errno) : "");
@@ -139,11 +133,13 @@ static DIR *audit_opendir(struct connection_struct *conn, const char *fname)
        return result;
 }
 
-static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
-       int result = default_vfs_ops.mkdir(conn, path, mode);
-
-       syslog(SYSLOG_PRIORITY, "mkdir %s %s%s\n", 
+       int result;
+       
+       result = VFS_NEXT_MKDIR(handle, conn, path, mode);
+       
+       syslog(audit_syslog_priority(handle), "mkdir %s %s%s\n", 
               path,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -151,11 +147,13 @@ static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t
        return result;
 }
 
-static int audit_rmdir(struct connection_struct *conn, const char *path)
+static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
-       int result = default_vfs_ops.rmdir(conn, path);
+       int result;
+
+       result = VFS_NEXT_RMDIR(handle, conn, path);
 
-       syslog(SYSLOG_PRIORITY, "rmdir %s %s%s\n", 
+       syslog(audit_syslog_priority(handle), "rmdir %s %s%s\n", 
               path, 
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -163,11 +161,13 @@ static int audit_rmdir(struct connection_struct *conn, const char *path)
        return result;
 }
 
-static int audit_open(struct connection_struct *conn, const char *fname, int flags, mode_t mode)
+static int audit_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode)
 {
-       int result = default_vfs_ops.open(conn, fname, flags, mode);
+       int result;
+
+       result = VFS_NEXT_OPEN(handle, conn, fname, flags, mode);
 
-       syslog(SYSLOG_PRIORITY, "open %s (fd %d) %s%s%s\n", 
+       syslog(audit_syslog_priority(handle), "open %s (fd %d) %s%s%s\n", 
               fname, result,
               ((flags & O_WRONLY) || (flags & O_RDWR)) ? "for writing " : "", 
               (result < 0) ? "failed: " : "",
@@ -176,11 +176,13 @@ static int audit_open(struct connection_struct *conn, const char *fname, int fla
        return result;
 }
 
-static int audit_close(struct files_struct *fsp, int fd)
+static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 {
-       int result = default_vfs_ops.close(fsp, fd);
+       int result;
+
+       result = VFS_NEXT_CLOSE(handle, fsp, fd);
 
-       syslog(SYSLOG_PRIORITY, "close fd %d %s%s\n",
+       syslog(audit_syslog_priority(handle), "close fd %d %s%s\n",
               fd,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -188,11 +190,13 @@ static int audit_close(struct files_struct *fsp, int fd)
        return result;
 }
 
-static int audit_rename(struct connection_struct *conn, const char *old, const char *new)
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
 {
-       int result = default_vfs_ops.rename(conn, old, new);
+       int result;
+
+       result = VFS_NEXT_RENAME(handle, conn, old, new);
 
-       syslog(SYSLOG_PRIORITY, "rename %s -> %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "rename %s -> %s %s%s\n",
               old, new,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -200,11 +204,13 @@ static int audit_rename(struct connection_struct *conn, const char *old, const c
        return result;    
 }
 
-static int audit_unlink(struct connection_struct *conn, const char *path)
+static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
-       int result = default_vfs_ops.unlink(conn, path);
+       int result;
+
+       result = VFS_NEXT_UNLINK(handle, conn, path);
 
-       syslog(SYSLOG_PRIORITY, "unlink %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "unlink %s %s%s\n",
               path,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -212,11 +218,13 @@ static int audit_unlink(struct connection_struct *conn, const char *path)
        return result;
 }
 
-static int audit_chmod(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
-       int result = default_vfs_ops.chmod(conn, path, mode);
+       int result;
+
+       result = VFS_NEXT_CHMOD(handle, conn, path, mode);
 
-       syslog(SYSLOG_PRIORITY, "chmod %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "chmod %s mode 0x%x %s%s\n",
               path, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -224,16 +232,13 @@ static int audit_chmod(struct connection_struct *conn, const char *path, mode_t
        return result;
 }
 
-static int audit_chmod_acl(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
        int result;
 
-       if ( !default_vfs_ops.chmod_acl )
-               return 0;
+       result = VFS_NEXT_CHMOD_ACL(handle, conn, path, mode);
 
-       result = default_vfs_ops.chmod_acl(conn, path, mode);
-
-       syslog(SYSLOG_PRIORITY, "chmod_acl %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "chmod_acl %s mode 0x%x %s%s\n",
               path, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -241,11 +246,13 @@ static int audit_chmod_acl(struct connection_struct *conn, const char *path, mod
        return result;
 }
 
-static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode)
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
-       int result = default_vfs_ops.fchmod(fsp, fd, mode);
+       int result;
 
-       syslog(SYSLOG_PRIORITY, "fchmod %s mode 0x%x %s%s\n",
+       result = VFS_NEXT_FCHMOD(handle, fsp, fd, mode);
+
+       syslog(audit_syslog_priority(handle), "fchmod %s mode 0x%x %s%s\n",
               fsp->fsp_name, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -253,16 +260,13 @@ static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode)
        return result;
 }
 
-static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
        int result;
 
-       if ( !default_vfs_ops.fchmod_acl )
-               return 0;
-
-       result = default_vfs_ops.fchmod_acl(fsp, fd, mode);
+       result = VFS_NEXT_FCHMOD_ACL(handle, fsp, fd, mode);
 
-       syslog(SYSLOG_PRIORITY, "fchmod_acl %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "fchmod_acl %s mode 0x%x %s%s\n",
               fsp->fsp_name, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -272,5 +276,5 @@ static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
 
 NTSTATUS vfs_audit_init(void)
 {
-       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "audit", audit_init);
+       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "audit", audit_op_tuples);
 }
index ef30ca70272502f358a7a97157ccc5a5419a4d25..c5ac2cfb4aca65554e6661a1829fecd4e473eda7 100644 (file)
@@ -5,6 +5,7 @@
  * Copyright (C) Tim Potter, 1999-2000
  * Copyright (C) Alexander Bokovoy, 2002
  * Copyright (C) John H Terpstra, 2003
+ * Copyright (C) Stefan (metze) Metzmacher, 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
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include "config.h"
-#include <stdio.h>
-#include <sys/stat.h>
-#ifdef HAVE_UTIME_H
-#include <utime.h>
-#endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-#include <syslog.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#include <errno.h>
-#include <string.h>
-#include <includes.h>
-#include <vfs.h>
-
-#ifndef SYSLOG_FACILITY
-#define SYSLOG_FACILITY   LOG_USER
-#endif
-
-#ifndef SYSLOG_PRIORITY
-#define SYSLOG_PRIORITY   LOG_NOTICE
-#endif
+
+#include "includes.h"
+
+static int vfs_extd_audit_debug_level = DBGC_VFS;
+
+#undef DBGC_CLASS
+#define DBGC_CLASS vfs_extd_audit_debug_level
 
 /* Function prototypes */
 
-static int audit_connect(struct connection_struct *conn, const char *svc, const char *user);
-static void audit_disconnect(struct connection_struct *conn);
-static DIR *audit_opendir(struct connection_struct *conn, const char *fname);
-static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t mode);
-static int audit_rmdir(struct connection_struct *conn, const char *path);
-static int audit_open(struct connection_struct *conn, const char *fname, int flags, mode_t mode);
-static int audit_close(struct files_struct *fsp, int fd);
-static int audit_rename(struct connection_struct *conn, const char *old, const char *new);
-static int audit_unlink(struct connection_struct *conn, const char *path);
-static int audit_chmod(struct connection_struct *conn, const char *path, mode_t mode);
-static int audit_chmod_acl(struct connection_struct *conn, const char *name, mode_t mode);
-static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode);
-static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode);
+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 DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname);
+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_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 int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new);
+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_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode);
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode);
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode);
 
 /* VFS operations */
 
-static struct vfs_ops default_vfs_ops;   /* For passthrough operation */
-static struct smb_vfs_handle_struct *audit_handle;
-
-static vfs_op_tuple audit_ops[] = {
+static vfs_op_tuple audit_op_tuples[] = {
     
        /* Disk operations */
 
-       {audit_connect,         SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_LOGGER},
-       {audit_disconnect,      SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_connect),         SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_disconnect),      SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_LOGGER},
 
        /* Directory operations */
 
-       {audit_opendir,         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_LOGGER},
-       {audit_mkdir,           SMB_VFS_OP_MKDIR,       SMB_VFS_LAYER_LOGGER},
-       {audit_rmdir,           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_opendir),         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_mkdir),           SMB_VFS_OP_MKDIR,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_rmdir),           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_LOGGER},
 
        /* File operations */
 
-       {audit_open,            SMB_VFS_OP_OPEN,        SMB_VFS_LAYER_LOGGER},
-       {audit_close,           SMB_VFS_OP_CLOSE,       SMB_VFS_LAYER_LOGGER},
-       {audit_rename,          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_LOGGER},
-       {audit_unlink,          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_LOGGER},
-       {audit_chmod,           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_LOGGER},
-       {audit_fchmod,          SMB_VFS_OP_FCHMOD,      SMB_VFS_LAYER_LOGGER},
-       {audit_chmod_acl,       SMB_VFS_OP_CHMOD_ACL,   SMB_VFS_LAYER_LOGGER},
-       {audit_fchmod_acl,      SMB_VFS_OP_FCHMOD_ACL,  SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_open),            SMB_VFS_OP_OPEN,        SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_close),           SMB_VFS_OP_CLOSE,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_rename),          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_unlink),          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_chmod),           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_fchmod),          SMB_VFS_OP_FCHMOD,      SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_chmod_acl),       SMB_VFS_OP_CHMOD_ACL,   SMB_VFS_LAYER_LOGGER},
+       {VFS_OP(audit_fchmod_acl),      SMB_VFS_OP_FCHMOD_ACL,  SMB_VFS_LAYER_LOGGER},
        
        /* Finish VFS operations definition */
        
-       {NULL,                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
+       {VFS_OP(NULL),                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 };
 
-/* VFS initialisation function.  Return vfs_op_tuple array back to SAMBA. */
 
-static vfs_op_tuple *audit_init(const struct vfs_ops *def_vfs_ops, 
-                       struct smb_vfs_handle_struct *vfs_handle)
+static int audit_syslog_facility(vfs_handle_struct *handle)
 {
-       memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
-       
-       audit_handle = vfs_handle;
+       /* fix me: let this be configurable by:
+        *      lp_param_enum(SNUM(handle->conn),(handle->param?handle->param:"extd_audit"),"syslog facility",
+        *              audit_enum_facility,LOG_USER); 
+        */
+       return LOG_USER;
+}
 
-       openlog("smbd_audit", LOG_PID, SYSLOG_FACILITY);
-       syslog(SYSLOG_PRIORITY, "VFS_INIT: vfs_ops loaded\n");
 
-       return audit_ops;
+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:"extd_audit"),"syslog priority",
+        *              audit_enum_priority,LOG_NOTICE); 
+        */
+       return LOG_NOTICE;
 }
 
 /* Implementation of vfs_ops.  Pass everything on to the default
    operation but log event first. */
 
-static int audit_connect(struct connection_struct *conn, const char *svc, const char *user)
+static int audit_connect(vfs_handle_struct *handle, connection_struct *conn, const char *svc, const char *user)
 {
-       syslog(SYSLOG_PRIORITY, "connect to service %s by user %s\n", 
+       int result;
+
+       openlog("smbd_audit", LOG_PID, audit_syslog_facility(handle));
+
+       syslog(audit_syslog_priority(handle), "connect to service %s by user %s\n", 
               svc, user);
        DEBUG(10, ("Connected to service %s as user %s\n",
               svc, user));
 
-       return default_vfs_ops.connect(conn, svc, user);
+       result = VFS_NEXT_CONNECT(handle, conn, svc, user);
+
+       return result;
 }
 
-static void audit_disconnect(struct connection_struct *conn)
+static void audit_disconnect(vfs_handle_struct *handle, connection_struct *conn)
 {
-       syslog(SYSLOG_PRIORITY, "disconnected\n");
+       syslog(audit_syslog_priority(handle), "disconnected\n");
        DEBUG(10, ("Disconnected from VFS module extd_audit\n"));
+       VFS_NEXT_DISCONNECT(handle, conn);
 
-       default_vfs_ops.disconnect(conn);
+       return;
 }
 
-static DIR *audit_opendir(struct connection_struct *conn, const char *fname)
+static DIR *audit_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname)
 {
-       DIR *result = default_vfs_ops.opendir(conn, fname);
+       DIR *result;
+
+       result = VFS_NEXT_OPENDIR(handle, conn, fname);
 
-       syslog(SYSLOG_PRIORITY, "opendir %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "opendir %s %s%s\n",
               fname,
               (result == NULL) ? "failed: " : "",
               (result == NULL) ? strerror(errno) : "");
-       DEBUG(1, ("vfs_extd_audit: opendir %s %s %s",
+       DEBUG(1, ("vfs_extd_audit: opendir %s %s %s\n",
               fname,
               (result == NULL) ? "failed: " : "",
               (result == NULL) ? strerror(errno) : ""));
@@ -149,11 +143,13 @@ static DIR *audit_opendir(struct connection_struct *conn, const char *fname)
        return result;
 }
 
-static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
-       int result = default_vfs_ops.mkdir(conn, path, mode);
-
-       syslog(SYSLOG_PRIORITY, "mkdir %s %s%s\n", 
+       int result;
+       
+       result = VFS_NEXT_MKDIR(handle, conn, path, mode);
+       
+       syslog(audit_syslog_priority(handle), "mkdir %s %s%s\n", 
               path,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -165,11 +161,13 @@ static int audit_mkdir(struct connection_struct *conn, const char *path, mode_t
        return result;
 }
 
-static int audit_rmdir(struct connection_struct *conn, const char *path)
+static int audit_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
-       int result = default_vfs_ops.rmdir(conn, path);
+       int result;
+       
+       result = VFS_NEXT_RMDIR(handle, conn, path);
 
-       syslog(SYSLOG_PRIORITY, "rmdir %s %s%s\n", 
+       syslog(audit_syslog_priority(handle), "rmdir %s %s%s\n", 
               path, 
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -181,11 +179,13 @@ static int audit_rmdir(struct connection_struct *conn, const char *path)
        return result;
 }
 
-static int audit_open(struct connection_struct *conn, const char *fname, int flags, mode_t mode)
+static int audit_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode)
 {
-       int result = default_vfs_ops.open(conn, fname, flags, mode);
+       int result;
+       
+       result = VFS_NEXT_OPEN(handle, conn, fname, flags, mode);
 
-       syslog(SYSLOG_PRIORITY, "open %s (fd %d) %s%s%s\n", 
+       syslog(audit_syslog_priority(handle), "open %s (fd %d) %s%s%s\n", 
               fname, result,
               ((flags & O_WRONLY) || (flags & O_RDWR)) ? "for writing " : "", 
               (result < 0) ? "failed: " : "",
@@ -198,11 +198,13 @@ static int audit_open(struct connection_struct *conn, const char *fname, int fla
        return result;
 }
 
-static int audit_close(struct files_struct *fsp, int fd)
+static int audit_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 {
-       int result = default_vfs_ops.close(fsp, fd);
+       int result;
+       
+       result = VFS_NEXT_CLOSE(handle, fsp, fd);
 
-       syslog(SYSLOG_PRIORITY, "close fd %d %s%s\n",
+       syslog(audit_syslog_priority(handle), "close fd %d %s%s\n",
               fd,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -214,11 +216,13 @@ static int audit_close(struct files_struct *fsp, int fd)
        return result;
 }
 
-static int audit_rename(struct connection_struct *conn, const char *old, const char *new)
+static int audit_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
 {
-       int result = default_vfs_ops.rename(conn, old, new);
+       int result;
+       
+       result = VFS_NEXT_RENAME(handle, conn, old, new);
 
-       syslog(SYSLOG_PRIORITY, "rename %s -> %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "rename %s -> %s %s%s\n",
               old, new,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -230,11 +234,13 @@ static int audit_rename(struct connection_struct *conn, const char *old, const c
        return result;    
 }
 
-static int audit_unlink(struct connection_struct *conn, const char *path)
+static int audit_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
-       int result = default_vfs_ops.unlink(conn, path);
+       int result;
+       
+       result = VFS_NEXT_UNLINK(handle, conn, path);
 
-       syslog(SYSLOG_PRIORITY, "unlink %s %s%s\n",
+       syslog(audit_syslog_priority(handle), "unlink %s %s%s\n",
               path,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -246,11 +252,13 @@ static int audit_unlink(struct connection_struct *conn, const char *path)
        return result;
 }
 
-static int audit_chmod(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
-       int result = default_vfs_ops.chmod(conn, path, mode);
+       int result;
 
-       syslog(SYSLOG_PRIORITY, "chmod %s mode 0x%x %s%s\n",
+       result = VFS_NEXT_CHMOD(handle, conn, path, mode);
+
+       syslog(audit_syslog_priority(handle), "chmod %s mode 0x%x %s%s\n",
               path, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -262,11 +270,13 @@ static int audit_chmod(struct connection_struct *conn, const char *path, mode_t
        return result;
 }
 
-static int audit_chmod_acl(struct connection_struct *conn, const char *path, mode_t mode)
+static int audit_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
-       int result = default_vfs_ops.chmod_acl(conn, path, mode);
+       int result;
+       
+       result = VFS_NEXT_CHMOD_ACL(handle, conn, path, mode);
 
-       syslog(SYSLOG_PRIORITY, "chmod_acl %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "chmod_acl %s mode 0x%x %s%s\n",
               path, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -278,11 +288,13 @@ static int audit_chmod_acl(struct connection_struct *conn, const char *path, mod
        return result;
 }
 
-static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode)
+static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
-       int result = default_vfs_ops.fchmod(fsp, fd, mode);
+       int result;
+       
+       result = VFS_NEXT_FCHMOD(handle, fsp, fd, mode);
 
-       syslog(SYSLOG_PRIORITY, "fchmod %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "fchmod %s mode 0x%x %s%s\n",
               fsp->fsp_name, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -294,11 +306,13 @@ static int audit_fchmod(struct files_struct *fsp, int fd, mode_t mode)
        return result;
 }
 
-static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
+static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
-       int result = default_vfs_ops.fchmod_acl(fsp, fd, mode);
+       int result;
+       
+       result = VFS_NEXT_FCHMOD_ACL(handle, fsp, fd, mode);
 
-       syslog(SYSLOG_PRIORITY, "fchmod_acl %s mode 0x%x %s%s\n",
+       syslog(audit_syslog_priority(handle), "fchmod_acl %s mode 0x%x %s%s\n",
               fsp->fsp_name, mode,
               (result < 0) ? "failed: " : "",
               (result < 0) ? strerror(errno) : "");
@@ -312,5 +326,18 @@ static int audit_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
 
 NTSTATUS vfs_extd_audit_init(void)
 {
-       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "extd_audit", audit_init);
+       NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "extd_audit", audit_op_tuples);
+       
+       if (NT_STATUS_IS_ERR(ret))
+               return ret;
+
+       vfs_extd_audit_debug_level = debug_add_class("extd_audit");
+       if (vfs_extd_audit_debug_level == -1) {
+               vfs_extd_audit_debug_level = DBGC_VFS;
+               DEBUG(0, ("vfs_extd_audit: Couldn't register custom debugging class!\n"));
+       } else {
+               DEBUG(10, ("vfs_extd_audit: Debug class number of 'extd_audit': %d\n", vfs_extd_audit_debug_level));
+       }
+       
+       return ret;
 }
index 3a18fbb730c00407c8cd5398769c2811bc73986d..2e1267ef1b8842996287ba86cb0b75ba34dd838b 100644 (file)
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include "config.h"
+#include "includes.h"
 
-#include <stdio.h>
-#include <sys/stat.h>
-#ifdef HAVE_UTIME_H
-#include <utime.h>
-#endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#include <errno.h>
-#include <string.h>
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
 
-#include <includes.h>
-#include <vfs.h>
-
-static struct vfs_ops default_vfs_ops;   /* For passthrough operation */
-static struct smb_vfs_handle_struct *fake_perms_handle; /* use fake_perms_handle->data for storing per-instance private data */
-
-static int fake_perms_stat(struct connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
+static int fake_perms_stat(vfs_handle_struct *handle, connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 {
-       int ret = default_vfs_ops.stat(conn, fname, sbuf);
+       int ret = -1;
+
+       ret = VFS_NEXT_STAT(handle, conn, fname, sbuf);
        if (ret == 0) {
                extern struct current_user current_user;
                
@@ -58,12 +43,15 @@ static int fake_perms_stat(struct connection_struct *conn, const char *fname, SM
                sbuf->st_uid = current_user.uid;
                sbuf->st_gid = current_user.gid;
        }
+
        return ret;
 }
 
-static int fake_perms_fstat(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
+static int fake_perms_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 {
-       int ret = default_vfs_ops.fstat(fsp, fd, sbuf);
+       int ret = -1;
+
+       ret = VFS_NEXT_FSTAT(handle, fsp, fd, sbuf);
        if (ret == 0) {
                extern struct current_user current_user;
                
@@ -78,210 +66,16 @@ static int fake_perms_fstat(struct files_struct *fsp, int fd, SMB_STRUCT_STAT *s
        return ret;
 }
 
-#if 0
-static size_t fake_perms_fget_nt_acl(struct files_struct *fsp, int fd, struct security_descriptor_info **ppdesc)
-{
-       return default_vfs_ops.fget_nt_acl(fsp, fd, ppdesc);
-}
-
-static size_t fake_perms_get_nt_acl(struct files_struct *fsp, const char *name, struct security_descriptor_info **ppdesc)
-{
-       return default_vfs_ops.get_nt_acl(fsp, name, ppdesc);
-}
-
-static BOOL fake_perms_fset_nt_acl(struct files_struct *fsp, int fd, uint32 security_info_sent, struct security_descriptor_info *psd)
-{
-       return default_vfs_ops.fset_nt_acl(fsp, fd, security_info_sent, psd);
-}
-
-static BOOL fake_perms_set_nt_acl(struct files_struct *fsp, const char *name, uint32 security_info_sent, struct security_descriptor_info *psd)
-{
-       return default_vfs_ops.set_nt_acl(fsp, name, security_info_sent, psd);
-}
-
-static BOOL fake_perms_chmod_acl(struct connection_struct *conn, const char *name, mode_t mode)
-{
-       return default_vfs_ops.chmod_acl(conn, name, mode);
-}
-
-static BOOL fake_perms_fchmod_acl(struct files_struct *fsp, int fd, mode_t mode)
-{
-       return default_vfs_ops.fchmod_acl(fsp, fd, mode);
-}
-
-static int fake_perms_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
-{
-       return default_vfs_ops.sys_acl_get_entry(conn, theacl, entry_id, entry_p);
-}
-
-static int fake_perms_sys_acl_get_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
-{
-       return default_vfs_ops.sys_acl_get_tag_type(conn, entry_d, tag_type_p);
-}
-
-static int fake_perms_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
-{
-       return default_vfs_ops.sys_acl_get_permset(conn, entry_d, permset_p);
-}
-
-static void *fake_perms_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
-{
-       return default_vfs_ops.sys_acl_get_qualifier(conn, entry_d);
-}
-
-static SMB_ACL_T fake_perms_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
-{
-       return default_vfs_ops.sys_acl_get_file(conn, path_p, type);
-}
-
-static SMB_ACL_T fake_perms_sys_acl_get_fd(struct files_struct *fsp, int fd)
-{
-       return default_vfs_ops.sys_acl_get_fd(fsp, fd);
-}
-
-static int fake_perms_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
-{
-       return default_vfs_ops.sys_acl_clear_perms(conn, permset);
-}
-
-static int fake_perms_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
-{
-       return default_vfs_ops.sys_acl_add_perm(conn, permset, perm);
-}
-
-static char *fake_perms_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
-{
-       return default_vfs_ops.sys_acl_to_text(conn, theacl, plen);
-}
-
-static SMB_ACL_T fake_perms_sys_acl_init(struct connection_struct *conn, int count)
-{
-       return default_vfs_ops.sys_acl_init(conn, count);
-}
-
-static int fake_perms_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
-{
-       return default_vfs_ops.sys_acl_create_entry(conn, pacl, pentry);
-}
-
-static int fake_perms_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
-{
-       return default_vfs_ops.sys_acl_set_tag_type(conn, entry, tagtype);
-}
-
-static int fake_perms_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
-{
-       return default_vfs_ops.sys_acl_set_qualifier(conn, entry, qual);
-}
-
-static int fake_perms_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
-{
-       return default_vfs_ops.sys_acl_set_permset(conn, entry, permset);
-}
-
-static int fake_perms_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
-{
-       return default_vfs_ops.sys_acl_valid(conn, theacl );
-}
-
-static int fake_perms_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
-{
-       return default_vfs_ops.sys_acl_set_file(conn, name, acltype, theacl);
-}
-
-static int fake_perms_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
-{
-       return default_vfs_ops.sys_acl_set_fd(fsp, fd, theacl);
-}
-
-static int fake_perms_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
-{
-       return default_vfs_ops.sys_acl_delete_def_file(conn, path);
-}
-
-static int fake_perms_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
-{
-       return default_vfs_ops.sys_acl_get_perm(conn, permset, perm);
-}
-
-static int fake_perms_sys_acl_free_text(struct connection_struct *conn, char *text)
-{
-       return default_vfs_ops.sys_acl_free_text(conn, text);
-}
-
-static int fake_perms_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
-{
-       return default_vfs_ops.sys_acl_free_acl(conn, posix_acl);
-}
-
-static int fake_perms_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
-{
-       return default_vfs_ops.sys_acl_free_qualifier(conn, qualifier, tagtype);
-}
-#endif
-
 /* VFS operations structure */
 
-static vfs_op_tuple fake_perms_ops[] = {
-
-       /* NT File ACL operations */
-#if 0
-       {fake_perms_fget_nt_acl,                SMB_VFS_OP_FGET_NT_ACL,         SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_get_nt_acl,         SMB_VFS_OP_GET_NT_ACL,          SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_fset_nt_acl,                SMB_VFS_OP_FSET_NT_ACL,         SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_set_nt_acl,         SMB_VFS_OP_SET_NT_ACL,          SMB_VFS_LAYER_TRANSPARENT},
-
-       /* POSIX ACL operations */
+static vfs_op_tuple fake_perms_ops[] = {       
+       {VFS_OP(fake_perms_stat),       SMB_VFS_OP_STAT,        SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(fake_perms_fstat),      SMB_VFS_OP_FSTAT,       SMB_VFS_LAYER_TRANSPARENT},
 
-       {fake_perms_chmod_acl,          SMB_VFS_OP_CHMOD_ACL,           SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_fchmod_acl,         SMB_VFS_OP_FCHMOD_ACL,          SMB_VFS_LAYER_TRANSPARENT},
-
-       {fake_perms_sys_acl_get_entry,  SMB_VFS_OP_SYS_ACL_GET_ENTRY,           SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_tag_type,       SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,        SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_permset,        SMB_VFS_OP_SYS_ACL_GET_PERMSET,         SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_qualifier,      SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,       SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_file,           SMB_VFS_OP_SYS_ACL_GET_FILE,            SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_fd,             SMB_VFS_OP_SYS_ACL_GET_FD,              SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_clear_perms,        SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,         SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_add_perm,           SMB_VFS_OP_SYS_ACL_ADD_PERM,            SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_to_text,            SMB_VFS_OP_SYS_ACL_TO_TEXT,             SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_init,               SMB_VFS_OP_SYS_ACL_INIT,                SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_create_entry,       SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,        SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_set_tag_type,       SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,        SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_set_qualifier,      SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,       SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_set_permset,        SMB_VFS_OP_SYS_ACL_SET_PERMSET,         SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_valid,              SMB_VFS_OP_SYS_ACL_VALID,               SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_set_file,           SMB_VFS_OP_SYS_ACL_SET_FILE,            SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_set_fd,             SMB_VFS_OP_SYS_ACL_SET_FD,              SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_delete_def_file,    SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,     SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_get_perm,           SMB_VFS_OP_SYS_ACL_GET_PERM,            SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_free_text,  SMB_VFS_OP_SYS_ACL_FREE_TEXT,           SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_free_acl,           SMB_VFS_OP_SYS_ACL_FREE_ACL,            SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_sys_acl_free_qualifier,     SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,      SMB_VFS_LAYER_TRANSPARENT},
-#endif
-       
-       {fake_perms_stat,       SMB_VFS_OP_STAT,        SMB_VFS_LAYER_TRANSPARENT},
-       {fake_perms_fstat,      SMB_VFS_OP_FSTAT,       SMB_VFS_LAYER_TRANSPARENT},
-       {NULL,  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
+       {NULL,                          SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 };
 
-/* VFS initialisation - return initialized vfs_op_tuple array back to Samba */
-
-static vfs_op_tuple *fake_perms_init(const struct vfs_ops *def_vfs_ops,
-                       struct smb_vfs_handle_struct *vfs_handle)
-{
-       DEBUG(3, ("Initialising default vfs hooks\n"));
-
-       memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
-       
-       /* Remember vfs_handle for further allocation and referencing of private
-          information in vfs_handle->data
-       */
-       fake_perms_handle = vfs_handle;
-       return fake_perms_ops;
-}
-
 NTSTATUS vfs_fake_perms_init(void)
 {
-       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_perms", fake_perms_init);
+       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_perms", fake_perms_ops);
 }
index 718bc2a35caaa04b10f9215ad9253a94834f44f0..f6c33c0a330e2de09e005f8129ebb7ce362b609d 100644 (file)
@@ -2,6 +2,7 @@
  * AppleTalk VFS module for Samba-3.x
  *
  * Copyright (C) Alexei Kotovich, 2002
+ * Copyright (C) Stefan (metze) Metzmacher, 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
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include "config.h"
-#include <stdio.h>
-#include <sys/stat.h>
-#ifdef HAVE_UTIME_H
-#include <utime.h>
-#endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#endif
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#include <errno.h>
-#include <string.h>
-#include <includes.h>
-#include <vfs.h>
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
 
 #define APPLEDOUBLE    ".AppleDouble"
 #define ADOUBLEMODE    0777
@@ -46,9 +35,6 @@ static int atalk_build_paths(TALLOC_CTX *ctx, const char *path,
 
 static int atalk_unlink_file(const char *path);
 
-static struct vfs_ops default_vfs_ops; /* For passthrough operation */
-static struct smb_vfs_handle_struct *atalk_handle;
-
 static int atalk_get_path_ptr(char *path)
 {
        int i   = 0;
@@ -187,11 +173,11 @@ static void atalk_rrmdir(TALLOC_CTX *ctx, char *path)
 
 /* Directory operations */
 
-DIR *atalk_opendir(struct connection_struct *conn, const char *fname)
+DIR *atalk_opendir(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *fname)
 {
        DIR *ret = 0;
-       
-       ret = default_vfs_ops.opendir(conn, fname);
+
+       ret = VFS_NEXT_OPENDIR(handle, conn, fname);
 
        /*
         * when we try to perform delete operation upon file which has fork
@@ -208,7 +194,7 @@ DIR *atalk_opendir(struct connection_struct *conn, const char *fname)
        return ret;
 }
 
-static int atalk_rmdir(struct connection_struct *conn, const char *path)
+static int atalk_rmdir(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path)
 {
        BOOL add = False;
        TALLOC_CTX *ctx = 0;
@@ -233,12 +219,12 @@ static int atalk_rmdir(struct connection_struct *conn, const char *path)
 
 exit_rmdir:
        talloc_destroy(ctx);
-       return default_vfs_ops.rmdir(conn, path);
+       return VFS_NEXT_RMDIR(handle, conn, path);
 }
 
 /* File operations */
 
-static int atalk_rename(struct connection_struct *conn, const char *old, const char *new)
+static int atalk_rename(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *old, const char *new)
 {
        int ret = 0;
        char *adbl_path = 0;
@@ -247,7 +233,7 @@ static int atalk_rename(struct connection_struct *conn, const char *old, const c
        SMB_STRUCT_STAT orig_info;
        TALLOC_CTX *ctx;
 
-       ret = default_vfs_ops.rename(conn, old, new);
+       ret = VFS_NEXT_RENAME(handle, conn, old, new);
 
        if (!conn || !old) return ret;
 
@@ -270,7 +256,7 @@ exit_rename:
        return ret;
 }
 
-static int atalk_unlink(struct connection_struct *conn, const char *path)
+static int atalk_unlink(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path)
 {
        int ret = 0, i;
        char *adbl_path = 0;
@@ -279,7 +265,7 @@ static int atalk_unlink(struct connection_struct *conn, const char *path)
        SMB_STRUCT_STAT orig_info;
        TALLOC_CTX *ctx;
 
-       ret = default_vfs_ops.unlink(conn, path);
+       ret = VFS_NEXT_UNLINK(handle, conn, path);
 
        if (!conn || !path) return ret;
 
@@ -326,7 +312,7 @@ exit_unlink:
        return ret;
 }
 
-static int atalk_chmod(struct connection_struct *conn, const char *path, mode_t mode)
+static int atalk_chmod(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, mode_t mode)
 {
        int ret = 0;
        char *adbl_path = 0;
@@ -335,7 +321,7 @@ static int atalk_chmod(struct connection_struct *conn, const char *path, mode_t
        SMB_STRUCT_STAT orig_info;
        TALLOC_CTX *ctx;
 
-       ret = default_vfs_ops.chmod(conn, path, mode);
+       ret = VFS_NEXT_CHMOD(handle, conn, path, mode);
 
        if (!conn || !path) return ret;
 
@@ -358,7 +344,7 @@ exit_chmod:
        return ret;
 }
 
-static int atalk_chown(struct connection_struct *conn, const char *path, uid_t uid, gid_t gid)
+static int atalk_chown(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 {
        int ret = 0;
        char *adbl_path = 0;
@@ -367,7 +353,7 @@ static int atalk_chown(struct connection_struct *conn, const char *path, uid_t u
        SMB_STRUCT_STAT orig_info;
        TALLOC_CTX *ctx;
 
-       ret = default_vfs_ops.chown(conn, path, uid, gid);
+       ret = VFS_NEXT_CHOWN(handle, conn, path, uid, gid);
 
        if (!conn || !path) return ret;
 
@@ -394,34 +380,22 @@ static vfs_op_tuple atalk_ops[] = {
     
        /* Directory operations */
 
-       {atalk_opendir,         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_TRANSPARENT},
-       {atalk_rmdir,           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_opendir),         SMB_VFS_OP_OPENDIR,     SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_rmdir),           SMB_VFS_OP_RMDIR,       SMB_VFS_LAYER_TRANSPARENT},
 
        /* File operations */
 
-       {atalk_rename,          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_TRANSPARENT},
-       {atalk_unlink,          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_TRANSPARENT},
-       {atalk_chmod,           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_TRANSPARENT},
-       {atalk_chown,           SMB_VFS_OP_CHOWN,       SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_rename),          SMB_VFS_OP_RENAME,      SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_unlink),          SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_chmod),           SMB_VFS_OP_CHMOD,       SMB_VFS_LAYER_TRANSPARENT},
+       {VFS_OP(atalk_chown),           SMB_VFS_OP_CHOWN,       SMB_VFS_LAYER_TRANSPARENT},
        
        /* Finish VFS operations definition */
        
-       {NULL,                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
+       {VFS_OP(NULL),                  SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 };
 
-/* VFS initialisation function.  Return vfs_op_tuple array back to SAMBA. */
-static vfs_op_tuple *netatalk_init(const struct vfs_ops *def_vfs_ops,
-  struct smb_vfs_handle_struct *vfs_handle)
-{
-       memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
-       
-       atalk_handle = vfs_handle;
-
-       DEBUG(3, ("ATALK: vfs module loaded\n"));
-       return atalk_ops;
-}
-
 NTSTATUS vfs_netatalk_init(void)
 {
-       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "netatalk", netatalk_init);
+       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "netatalk", atalk_ops);
 }
index 87dea944ac05440789429789c600a1c2c6183ba6..03e2c5eabce5bea7b7e87cdfda0943a29ac01a54 100644 (file)
@@ -6,6 +6,7 @@
  * Copyright (C) 2002, Alexander Bokovoy - cascaded VFS adoption,
  * Copyright (C) 2002, Juergen Hasch - added some options.
  * Copyright (C) 2002, Simo Sorce
+ * Copyright (C) 2002, Stefan (metze) Metzmacher
  *
  * 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
@@ -30,45 +31,10 @@ static int vfs_recycle_debug_level = DBGC_VFS;
 
 #undef DBGC_CLASS
 #define DBGC_CLASS vfs_recycle_debug_level
-
-static const char *delimiter = "|";            /* delimiter for options */
-
-/* One per connection */
-
-typedef struct recycle_bin_struct
-{
-       TALLOC_CTX *mem_ctx;
-       char    *repository;            /* name of the recycle bin directory */
-       BOOL    keep_dir_tree;          /* keep directory structure of deleted file in recycle bin */
-       BOOL    versions;               /* create versions of deleted files with identical name */
-       BOOL    touch;                  /* touch access date of deleted file */
-       char    *exclude;               /* which files to exclude */
-       char    *exclude_dir;           /* which directories to exclude */
-       char    *noversions;            /* which files to exclude from versioning */
-       SMB_OFF_T maxsize;              /* maximum file size to be saved */
-} recycle_bin_struct;
-
-typedef struct recycle_bin_connections {
-       int conn;
-       recycle_bin_struct *data;
-       struct recycle_bin_connections *next;
-} recycle_bin_connections;
-
-typedef struct recycle_bin_private_data {
-       TALLOC_CTX *mem_ctx;
-       recycle_bin_connections *conns;
-} recycle_bin_private_data;
-
-struct smb_vfs_handle_struct *recycle_bin_private_handle;
-
-/* VFS operations */
-static struct vfs_ops default_vfs_ops;   /* For passthrough operation */
-
-static int recycle_connect(struct connection_struct *conn, const char *service, const char *user);
-static void recycle_disconnect(struct connection_struct *conn);
-static int recycle_unlink(connection_struct *, const char *);
-
-#define VFS_OP(x) ((void *) x)
+static int recycle_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user);
+static void recycle_disconnect(vfs_handle_struct *handle, connection_struct *conn);
+static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *name);
 
 static vfs_op_tuple recycle_ops[] = {
 
@@ -82,179 +48,116 @@ static vfs_op_tuple recycle_ops[] = {
        {NULL,                          SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
 };
 
-/**
- * VFS initialisation function.
- *
- * @retval initialised vfs_op_tuple array
- **/
-static vfs_op_tuple *recycle_init(const struct vfs_ops *def_vfs_ops,
-                       struct smb_vfs_handle_struct *vfs_handle)
+static int recycle_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user)
 {
-       TALLOC_CTX *mem_ctx = NULL;
+       DEBUG(10,("recycle_connect() connect to service[%s] as user[%s].\n",
+               service,user));
 
-       DEBUG(10, ("Initializing VFS module recycle\n"));
-       memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
-       vfs_recycle_debug_level = debug_add_class("vfs_recycle_bin");
-       if (vfs_recycle_debug_level == -1) {
-               vfs_recycle_debug_level = DBGC_VFS;
-               DEBUG(0, ("vfs_recycle: Couldn't register custom debugging class!\n"));
-       } else {
-               DEBUG(0, ("vfs_recycle: Debug class number of 'vfs_recycle': %d\n", vfs_recycle_debug_level));
-       }
-
-       recycle_bin_private_handle = vfs_handle;
-       if (!(mem_ctx = talloc_init("recycle bin data"))) {
-               DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
-               return NULL;
-       }
+       return VFS_NEXT_CONNECT(handle, conn, service, user);           
+}
 
-       recycle_bin_private_handle->data = talloc(mem_ctx, sizeof(recycle_bin_private_data));
-       if (recycle_bin_private_handle->data == NULL) {
-               DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
-               return NULL;
-       }
-       ((recycle_bin_private_data *)(recycle_bin_private_handle->data))->mem_ctx = mem_ctx;
-       ((recycle_bin_private_data *)(recycle_bin_private_handle->data))->conns = NULL;
+static void recycle_disconnect(vfs_handle_struct *handle, connection_struct *conn)
+{
+       DEBUG(10,("recycle_disconnect() connect to service[%s].\n",
+               lp_servicename(SNUM(conn))));
 
-       return recycle_ops;
+       VFS_NEXT_DISCONNECT(handle, conn);      
 }
 
-static int recycle_connect(struct connection_struct *conn, const char *service, const char *user)
+static const char *recycle_repository(vfs_handle_struct *handle)
 {
-       TALLOC_CTX *ctx = NULL;
-       recycle_bin_struct *recbin;
-       recycle_bin_connections *recconn;
-       recycle_bin_connections *recconnbase;
-       recycle_bin_private_data *recdata;
-       const char *tmp_str;
+       const char *tmp_str = NULL;
+       
 
-       DEBUG(10, ("Called for service %s (%d) as user %s\n", service, SNUM(conn), user));
+       tmp_str = lp_parm_const_string(SNUM(handle->conn), "recycle", "repository",".recycle");
 
-       if (recycle_bin_private_handle)
-               recdata = (recycle_bin_private_data *)(recycle_bin_private_handle->data);
-       else {
-               DEBUG(0, ("Recycle bin not initialized!\n"));
-               return -1;
-       }
+       DEBUG(10, ("recycle: repository = %s\n", tmp_str));
+       
+       return tmp_str;
+}
 
-       if (!(ctx = talloc_init("recycle bin connection"))) {
-               DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
-               return -1;
-       }
+static BOOL recycle_keep_dir_tree(vfs_handle_struct *handle)
+{
+       BOOL ret;
+       
+       ret = lp_parm_bool(SNUM(handle->conn), "recycle", "keeptree", False);
 
-       recbin = talloc_zero(ctx, sizeof(recycle_bin_struct));
-       if (recbin == NULL) {
-               DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
-               return -1;
-       }
-       recbin->mem_ctx = ctx;
-
-       /* parse configuration options */
-       if ((tmp_str = lp_parm_const_string(SNUM(conn), "vfs_recycle_bin", "repository", ".recycle")) != NULL) {
-               recbin->repository = talloc_sub_conn(recbin->mem_ctx, conn, tmp_str);
-               ALLOC_CHECK(recbin->repository, error);
-               trim_string(recbin->repository, "/", "/");
-               DEBUG(5, ("recycle.bin: repository = %s\n", recbin->repository));
-       } else {
-               DEBUG(0,("recycle.bin: no repository found (fail) !\n"));
-               goto error;
-       }
+       DEBUG(10, ("recycle_bin: keeptree = %s\n", ret?"True":"False"));
        
-       recbin->keep_dir_tree = lp_parm_bool(SNUM(conn), "vfs_recycle_bin", "keeptree", False);
-       DEBUG(5, ("recycle.bin: keeptree = %d\n", recbin->keep_dir_tree));
+       return ret;
+}
+
+static BOOL recycle_versions(vfs_handle_struct *handle)
+{
+       BOOL ret;
+
+       ret = lp_parm_bool(SNUM(handle->conn), "recycle", "versions", False);
+
+       DEBUG(10, ("recycle: versions = %s\n", ret?"True":"False"));
        
-       recbin->versions = lp_parm_bool(SNUM(conn), "vfs_recycle_bin", "versions", False);
-       DEBUG(5, ("recycle.bin: versions = %d\n", recbin->versions));
+       return ret;
+}
+
+static BOOL recycle_touch(vfs_handle_struct *handle)
+{
+       BOOL ret;
+
+       ret = lp_parm_bool(SNUM(handle->conn), "recycle", "touch", False);
+
+       DEBUG(10, ("recycle: touch = %s\n", ret?"True":"False"));
        
-       recbin->touch = lp_parm_bool(SNUM(conn), "vfs_recycle_bin", "touch", False);
-       DEBUG(5, ("recycle.bin: touch = %d\n", recbin->touch));
+       return ret;
+}
 
-       recbin->maxsize = lp_parm_ulong(SNUM(conn), "vfs_recycle_bin", "maxsize" , 0);
-       if (recbin->maxsize == 0) {
-               recbin->maxsize = -1;
-               DEBUG(5, ("recycle.bin: maxsize = -infinite-\n"));
-       } else {
-               DEBUG(5, ("recycle.bin: maxsize = %ld\n", (long int)recbin->maxsize));
-       }
+static const char **recycle_exclude(vfs_handle_struct *handle)
+{
+       const char **tmp_lp;
+       
+       tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude", NULL);
 
-       if ((tmp_str = lp_parm_const_string(SNUM(conn), "vfs_recycle_bin", "exclude", "")) != NULL) {
-               recbin->exclude = talloc_strdup(recbin->mem_ctx, tmp_str);
-               ALLOC_CHECK(recbin->exclude, error);
-               DEBUG(5, ("recycle.bin: exclude = %s\n", recbin->exclude));
-       }
-       if ((tmp_str = lp_parm_const_string(SNUM(conn), "vfs_recycle_bin", "exclude_dir", "")) != NULL) {
-               recbin->exclude_dir = talloc_strdup(recbin->mem_ctx, tmp_str);
-               ALLOC_CHECK(recbin->exclude_dir, error);
-               DEBUG(5, ("recycle.bin: exclude_dir = %s\n", recbin->exclude_dir));
-       }
-       if ((tmp_str = lp_parm_const_string(SNUM(conn), "vfs_recycle_bin", "noversions", "")) != NULL) {
-               recbin->noversions = talloc_strdup(recbin->mem_ctx, tmp_str);
-               ALLOC_CHECK(recbin->noversions, error);
-               DEBUG(5, ("recycle.bin: noversions = %s\n", recbin->noversions));
-       }
+       DEBUG(10, ("recycle: exclude = %s ...\n", tmp_lp?*tmp_lp:""));
+       
+       return tmp_lp;
+}
 
-       recconn = talloc(recdata->mem_ctx, sizeof(recycle_bin_connections));
-       if (recconn == NULL) {
-               DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
-               goto error;
-       }
-       recconn->conn = SNUM(conn);
-       recconn->data = recbin;
-       recconn->next = NULL;
-       if (recdata->conns) {
-               recconnbase = recdata->conns;
-               while (recconnbase->next != NULL) recconnbase = recconnbase->next;
-               recconnbase->next = recconn;
-       } else {
-               recdata->conns = recconn;
-       }
-       return default_vfs_ops.connect(conn, service, user);
+static const char **recycle_exclude_dir(vfs_handle_struct *handle)
+{
+       const char **tmp_lp;
+       
+       tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude_dir", NULL);
 
-error:
-       talloc_destroy(ctx);
-       return -1;
+       DEBUG(10, ("recycle: exclude_dir = %s ...\n", tmp_lp?*tmp_lp:""));
+       
+       return tmp_lp;
 }
 
-static void recycle_disconnect(struct connection_struct *conn)
+static const char **recycle_noversions(vfs_handle_struct *handle)
 {
-       recycle_bin_private_data *recdata;
-       recycle_bin_connections *recconn;
+       const char **tmp_lp;
+       
+       tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "noversions", NULL);
 
-       DEBUG(10, ("Disconnecting VFS module recycle bin\n"));
+       DEBUG(10, ("recycle: noversions = %s\n", tmp_lp?*tmp_lp:""));
+       
+       return tmp_lp;
+}
 
-       if (recycle_bin_private_handle)
-               recdata = (recycle_bin_private_data *)(recycle_bin_private_handle->data);
-       else {
-               DEBUG(0, ("Recycle bin not initialized!\n"));
-               return;
-       }
+static int recycle_maxsize(vfs_handle_struct *handle)
+{
+       int maxsize;
+       
+       maxsize = lp_parm_int(SNUM(handle->conn), "recycle", "maxsize", -1);
 
-       if (recdata) {
-               if (recdata->conns) {
-                       if (recdata->conns->conn == SNUM(conn)) {
-                               talloc_destroy(recdata->conns->data->mem_ctx);
-                               recdata->conns = recdata->conns->next;
-                       } else {
-                               recconn = recdata->conns;
-                               while (recconn->next) {
-                                       if (recconn->next->conn == SNUM(conn)) {
-                                               talloc_destroy(recconn->next->data->mem_ctx);
-                                               recconn->next = recconn->next->next;
-                                               break;
-                                       }
-                                       recconn = recconn->next;
-                               }
-                       }
-               }
-       }
-       default_vfs_ops.disconnect(conn);
+       DEBUG(10, ("recycle: maxsize = %d\n", maxsize));
+       
+       return maxsize;
 }
 
-static BOOL recycle_directory_exist(connection_struct *conn, const char *dname)
+static BOOL recycle_directory_exist(vfs_handle_struct *handle, const char *dname)
 {
        SMB_STRUCT_STAT st;
 
-       if (default_vfs_ops.stat(conn, dname, &st) == 0) {
+       if (VFS_NEXT_STAT(handle, handle->conn, dname, &st) == 0) {
                if (S_ISDIR(st.st_mode)) {
                        return True;
                }
@@ -263,11 +166,11 @@ static BOOL recycle_directory_exist(connection_struct *conn, const char *dname)
        return False;
 }
 
-static BOOL recycle_file_exist(connection_struct *conn, const char *fname)
+static BOOL recycle_file_exist(vfs_handle_struct *handle, const char *fname)
 {
        SMB_STRUCT_STAT st;
 
-       if (default_vfs_ops.stat(conn, fname, &st) == 0) {
+       if (VFS_NEXT_STAT(handle, handle->conn, fname, &st) == 0) {
                if (S_ISREG(st.st_mode)) {
                        return True;
                }
@@ -282,13 +185,15 @@ static BOOL recycle_file_exist(connection_struct *conn, const char *fname)
  * @param fname file name
  * @return size in bytes
  **/
-static SMB_OFF_T recycle_get_file_size(connection_struct *conn, const char *fname)
+static SMB_OFF_T recycle_get_file_size(vfs_handle_struct *handle, const char *fname)
 {
        SMB_STRUCT_STAT st;
-       if (default_vfs_ops.stat(conn, fname, &st) != 0) {
-               DEBUG(0,("recycle.bin: stat for %s returned %s\n", fname, strerror(errno)));
+
+       if (VFS_NEXT_STAT(handle, handle->conn, fname, &st) != 0) {
+               DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
                return (SMB_OFF_T)0;
        }
+
        return(st.st_size);
 }
 
@@ -298,7 +203,7 @@ static SMB_OFF_T recycle_get_file_size(connection_struct *conn, const char *fnam
  * @param dname Directory tree to be created
  * @return Returns True for success
  **/
-static BOOL recycle_create_dir(connection_struct *conn, const char *dname)
+static BOOL recycle_create_dir(vfs_handle_struct *handle, const char *dname)
 {
        int len;
        mode_t mode;
@@ -322,18 +227,18 @@ static BOOL recycle_create_dir(connection_struct *conn, const char *dname)
        /* Create directory tree if neccessary */
        for(token = strtok(tok_str, "/"); token; token = strtok(NULL, "/")) {
                safe_strcat(new_dir, token, len);
-               if (recycle_directory_exist(conn, new_dir))
-                       DEBUG(10, ("recycle.bin: dir %s already exists\n", new_dir));
+               if (recycle_directory_exist(handle, new_dir))
+                       DEBUG(10, ("recycle: dir %s already exists\n", new_dir));
                else {
-                       DEBUG(5, ("recycle.bin: creating new dir %s\n", new_dir));
-                       if (default_vfs_ops.mkdir(conn, new_dir, mode) != 0) {
-                               DEBUG(1,("recycle.bin: mkdir failed for %s with error: %s\n", new_dir, strerror(errno)));
+                       DEBUG(5, ("recycle: creating new dir %s\n", new_dir));
+                       if (VFS_NEXT_MKDIR(handle, handle->conn, new_dir, mode) != 0) {
+                               DEBUG(1,("recycle: mkdir failed for %s with error: %s\n", new_dir, strerror(errno)));
                                ret = False;
                                goto done;
                        }
                }
                safe_strcat(new_dir, "/", len);
-               }
+       }
 
        ret = True;
 done:
@@ -348,30 +253,22 @@ done:
  * @param needle string to be matched exactly to haystack
  * @return True if found
  **/
-static BOOL checkparam(const char *haystack, const char *needle)
+static BOOL checkparam(const char **haystack_list, const char *needle)
 {
-       char *token;
-       char *tok_str;
-       char *tmp_str;
-       BOOL ret = False;
+       int i;
 
-       if (haystack == NULL || strlen(haystack) == 0 || needle == NULL || strlen(needle) == 0) {
+       if (haystack_list == NULL || haystack_list[0] == NULL ||
+               *haystack_list[0] == '\0' || needle == NULL || *needle == '\0') {
                return False;
        }
 
-       tmp_str = strdup(haystack);
-       ALLOC_CHECK(tmp_str, done);
-       token = tok_str = tmp_str;
-
-       for(token = strtok(tok_str, delimiter); token; token = strtok(NULL, delimiter)) {
-               if(strcmp(token, needle) == 0) {
-                       ret = True;
-                       goto done;
+       for(i=0; haystack_list[i] ; i++) {
+               if(strequal(haystack_list[i], needle)) {
+                       return True;
                }
        }
-done:
-       SAFE_FREE(tmp_str);
-       return ret;
+
+       return False;
 }
 
 /**
@@ -380,110 +277,87 @@ done:
  * @param needle string to be matched exectly to haystack including pattern matching
  * @return True if found
  **/
-static BOOL matchparam(const char *haystack, const char *needle)
+static BOOL matchparam(const char **haystack_list, const char *needle)
 {
-       char *token;
-       char *tok_str;
-       char *tmp_str;
-       BOOL ret = False;
+       int i;
 
-       if (haystack == NULL || strlen(haystack) == 0 || needle == NULL || strlen(needle) == 0) {
+       if (haystack_list == NULL || haystack_list[0] == NULL ||
+               *haystack_list[0] == '\0' || needle == NULL || *needle == '\0') {
                return False;
        }
 
-       tmp_str = strdup(haystack);
-       ALLOC_CHECK(tmp_str, done);
-       token = tok_str = tmp_str;
-
-       for(token = strtok(tok_str, delimiter); token; token = strtok(NULL, delimiter)) {
-               if (!unix_wild_match(token, needle)) {
-                       ret = True;
-                       goto done;
+       for(i=0; haystack_list[i] ; i++) {
+               if(!unix_wild_match((char *)haystack_list[i], (char *)needle)) {
+                       return True;
                }
        }
-done:
-       SAFE_FREE(tmp_str);
-       return ret;
+
+       return False;
 }
 
 /**
  * Touch access date
  **/
-static void recycle_touch(connection_struct *conn, const char *fname)
+static void recycle_do_touch(vfs_handle_struct *handle, const char *fname)
 {
        SMB_STRUCT_STAT st;
        struct utimbuf tb;
        time_t currtime;
-
-       if (default_vfs_ops.stat(conn, fname, &st) != 0) {
-               DEBUG(0,("recycle.bin: stat for %s returned %s\n", fname, strerror(errno)));
+       
+       if (VFS_NEXT_STAT(handle, handle->conn, fname, &st) != 0) {
+               DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
                return;
        }
        currtime = time(&currtime);
        tb.actime = currtime;
        tb.modtime = st.st_mtime;
 
-       if (default_vfs_ops.utime(conn, fname, &tb) == -1 )
-               DEBUG(0, ("recycle.bin: touching %s failed, reason = %s\n", fname, strerror(errno)));
+       if (VFS_NEXT_UTIME(handle, handle->conn, fname, &tb) == -1 ) {
+               DEBUG(0, ("recycle: touching %s failed, reason = %s\n", fname, strerror(errno)));
        }
+}
 
 /**
  * Check if file should be recycled
  **/
-static int recycle_unlink(connection_struct *conn, const char *file_name)
+static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *file_name)
 {
-       recycle_bin_private_data *recdata;
-       recycle_bin_connections *recconn;
-       recycle_bin_struct *recbin;
        char *path_name = NULL;
                char *temp_name = NULL;
        char *final_name = NULL;
        const char *base;
-       int i;
-/*     SMB_BIG_UINT dfree, dsize, bsize;       */
+       char *repository = NULL;
+       int i = 1;
+       int maxsize;
        SMB_OFF_T file_size; /* space_avail;    */
        BOOL exist;
        int rc = -1;
 
-       recbin = NULL;
-       if (recycle_bin_private_handle) {
-               recdata = (recycle_bin_private_data *)(recycle_bin_private_handle->data);
-               if (recdata) {
-                       if (recdata->conns) {
-                               recconn = recdata->conns;
-                               while (recconn && recconn->conn != SNUM(conn)) recconn = recconn->next;
-                               if (recconn != NULL) {
-                                       recbin = recconn->data;
-                               }
-                       }
-               }
-       }
-       if (recbin == NULL) {
-               DEBUG(0, ("Recycle bin not initialized!\n"));
-               rc = default_vfs_ops.unlink(conn, file_name);
-               goto done;
-       }
-
-       if(!recbin->repository || *(recbin->repository) == '\0') {
-               DEBUG(3, ("Recycle path not set, purging %s...\n", file_name));
-               rc = default_vfs_ops.unlink(conn, file_name);
+       repository = alloc_sub_conn(conn, (char *)recycle_repository(handle));
+       ALLOC_CHECK(repository, done);
+       /* shouldn't we allow absolute path names here? --metze */
+       trim_string(repository, "/", "/");
+       
+       if(!repository || *(repository) == '\0') {
+               DEBUG(3, ("recycle: repository path not set, purging %s...\n", file_name));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
        /* we don't recycle the recycle bin... */
-       if (strncmp(file_name, recbin->repository, strlen(recbin->repository)) == 0) {
-               DEBUG(3, ("File is within recycling bin, unlinking ...\n"));
-               rc = default_vfs_ops.unlink(conn, file_name);
+       if (strncmp(file_name, repository, strlen(repository)) == 0) {
+               DEBUG(3, ("recycle: File is within recycling bin, unlinking ...\n"));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
-       file_size = recycle_get_file_size(conn, file_name);
+       file_size = recycle_get_file_size(handle, file_name);
        /* it is wrong to purge filenames only because they are empty imho
         *   --- simo
         *
        if(fsize == 0) {
-               DEBUG(3, ("File %s is empty, purging...\n", file_name));
-               rc = default_vfs_ops.unlink(conn,file_name);
+               DEBUG(3, ("recycle: File %s is empty, purging...\n", file_name));
+               rc = VFS_NEXT_UNLINK(handle,conn,file_name);
                goto done;
        }
         */
@@ -492,20 +366,21 @@ static int recycle_unlink(connection_struct *conn, const char *file_name)
         * not greater then maxsize, not the size of the single file, also it is better
         * to remove older files
         */
-       if(recbin->maxsize > 0 && file_size > recbin->maxsize) {
-               DEBUG(3, ("File %s exceeds maximum recycle size, purging... \n", file_name));
-               rc = default_vfs_ops.unlink(conn, file_name);
+       maxsize = recycle_maxsize(handle);
+       if(maxsize > 0 && file_size > maxsize) {
+               DEBUG(3, ("recycle: File %s exceeds maximum recycle size, purging... \n", file_name));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
        /* FIXME: this is wrong: moving files with rename does not change the disk space
         * allocation
         *
-       space_avail = default_vfs_ops.disk_free(conn, ".", True, &bsize, &dfree, &dsize) * 1024L;
+       space_avail = VFS_NEXT_DISK_FREE(handle, conn, ".", True, &bsize, &dfree, &dsize) * 1024L;
        DEBUG(5, ("space_avail = %Lu, file_size = %Lu\n", space_avail, file_size));
        if(space_avail < file_size) {
-               DEBUG(3, ("Not enough diskspace, purging file %s\n", file_name));
-               rc = default_vfs_ops.unlink(conn, file_name);
+               DEBUG(3, ("recycle: Not enough diskspace, purging file %s\n", file_name));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
         */
@@ -524,13 +399,13 @@ static int recycle_unlink(connection_struct *conn, const char *file_name)
                base++;
        }
 
-       DEBUG(10, ("recycle.bin: fname = %s\n", file_name));    /* original filename with path */
-       DEBUG(10, ("recycle.bin: fpath = %s\n", path_name));    /* original path */
-       DEBUG(10, ("recycle.bin: base = %s\n", base));          /* filename without path */
+       DEBUG(10, ("recycle: fname = %s\n", file_name));        /* original filename with path */
+       DEBUG(10, ("recycle: fpath = %s\n", path_name));        /* original path */
+       DEBUG(10, ("recycle: base = %s\n", base));              /* filename without path */
 
-       if (matchparam(recbin->exclude, base)) {
-               DEBUG(3, ("recycle.bin: file %s is excluded \n", base));
-               rc = default_vfs_ops.unlink(conn, file_name);
+       if (matchparam(recycle_exclude(handle), base)) {
+               DEBUG(3, ("recycle: file %s is excluded \n", base));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
@@ -538,72 +413,85 @@ static int recycle_unlink(connection_struct *conn, const char *file_name)
         * we shoud check for every level 1, 1/2, 1/2/3, 1/2/3/4 .... 
         *      ---simo
         */
-       if (checkparam(recbin->exclude_dir, path_name)) {
-               DEBUG(3, ("recycle.bin: directory %s is excluded \n", path_name));
-               rc = default_vfs_ops.unlink(conn, file_name);
+       if (checkparam(recycle_exclude_dir(handle), path_name)) {
+               DEBUG(3, ("recycle: directory %s is excluded \n", path_name));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
-       /* see if we need to recreate the original directory structure in the recycle bin */
-       if (recbin->keep_dir_tree == True) {
-               asprintf(&temp_name, "%s/%s", recbin->repository, path_name);
+       if (recycle_keep_dir_tree(handle) == True) {
+               asprintf(&temp_name, "%s/%s", repository, path_name);
        } else {
-               temp_name = strdup(recbin->repository);
+               temp_name = strdup(repository);
        }
        ALLOC_CHECK(temp_name, done);
 
-       exist = recycle_directory_exist(conn, temp_name);
+       exist = recycle_directory_exist(handle, temp_name);
        if (exist) {
-               DEBUG(10, ("recycle.bin: Directory already exists\n"));
+               DEBUG(10, ("recycle: Directory already exists\n"));
        } else {
-               DEBUG(10, ("recycle.bin: Creating directory %s\n", temp_name));
-               if (recycle_create_dir(conn, temp_name) == False) {
-                       DEBUG(3, ("Could not create directory, purging %s...\n", file_name));
-                       rc = default_vfs_ops.unlink(conn, file_name);
+               DEBUG(10, ("recycle: Creating directory %s\n", temp_name));
+               if (recycle_create_dir(handle, temp_name) == False) {
+                       DEBUG(3, ("recycle: Could not create directory, purging %s...\n", file_name));
+                       rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                        goto done;
                }
        }
 
        asprintf(&final_name, "%s/%s", temp_name, base);
        ALLOC_CHECK(final_name, done);
-       DEBUG(10, ("recycle.bin: recycled file name: %s\n", temp_name));                /* new filename with path */
+       DEBUG(10, ("recycle: recycled file name: %s\n", final_name));           /* new filename with path */
 
        /* check if we should delete file from recycle bin */
-       if (recycle_file_exist(conn, final_name)) {
-               if (recbin->versions == False || matchparam(recbin->noversions, base) == True) {
-                       DEBUG(3, ("recycle.bin: Removing old file %s from recycle bin\n", final_name));
-                       if (default_vfs_ops.unlink(conn, final_name) != 0) {
-                               DEBUG(1, ("recycle.bin: Error deleting old file: %s\n", strerror(errno)));
+       if (recycle_file_exist(handle, final_name)) {
+               if (recycle_versions(handle) == False || matchparam(recycle_noversions(handle), base) == True) {
+                       DEBUG(3, ("recycle: Removing old file %s from recycle bin\n", final_name));
+                       if (VFS_NEXT_UNLINK(handle, conn, final_name) != 0) {
+                               DEBUG(1, ("recycle: Error deleting old file: %s\n", strerror(errno)));
                        }
                }
        }
 
        /* rename file we move to recycle bin */
        i = 1;
-       while (recycle_file_exist(conn, final_name)) {
-               snprintf(final_name, PATH_MAX, "%s/Copy #%d of %s", temp_name, i++, base);
+       while (recycle_file_exist(handle, final_name)) {
+               snprintf(final_name, PATH_MAX -1, "%s/Copy #%d of %s", temp_name, i++, base);
        }
 
-       DEBUG(10, ("recycle.bin: Moving %s to %s\n", file_name, final_name));
-       rc = default_vfs_ops.rename(conn, file_name, final_name);
+       DEBUG(10, ("recycle: Moving %s to %s\n", file_name, final_name));
+       rc = VFS_NEXT_RENAME(handle, conn, file_name, final_name);
        if (rc != 0) {
-               DEBUG(3, ("recycle.bin: Move error %d (%s), purging file %s (%s)\n", errno, strerror(errno), file_name, final_name));
-               rc = default_vfs_ops.unlink(conn, file_name);
+               DEBUG(3, ("recycle: Move error %d (%s), purging file %s (%s)\n", errno, strerror(errno), file_name, final_name));
+               rc = VFS_NEXT_UNLINK(handle, conn, file_name);
                goto done;
        }
 
        /* touch access date of moved file */
-       if (recbin->touch == True )
-               recycle_touch(conn, final_name);
+       if (recycle_touch(handle) == True )
+               recycle_do_touch(handle, final_name);
 
 done:
        SAFE_FREE(path_name);
        SAFE_FREE(temp_name);
        SAFE_FREE(final_name);
+       SAFE_FREE(repository);
        return rc;
 }
 
 NTSTATUS vfs_recycle_init(void)
-{  
-       return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "recycle", recycle_init);
+{
+       NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "recycle", recycle_ops);
+
+       if (NT_STATUS_IS_ERR(ret))
+               return ret;
+       
+       vfs_recycle_debug_level = debug_add_class("recycle");
+       if (vfs_recycle_debug_level == -1) {
+               vfs_recycle_debug_level = DBGC_VFS;
+               DEBUG(0, ("vfs_recycle: Couldn't register custom debugging class!\n"));
+       } else {
+               DEBUG(10, ("vfs_recycle: Debug class number of 'recycle': %d\n", vfs_recycle_debug_level));
+       }
+       
+       return ret;
 }
index 69a315d4e40bf4236792a4c6ed95eb58c5fdf208..73b0929cabcf1e8dbd6e00f05cb057513b8020cf 100644 (file)
@@ -169,14 +169,14 @@ BOOL is_msdfs_link(connection_struct* conn, char* path,
        if (sbufp == NULL)
                sbufp = &st;
 
-       if (conn->vfs_ops.lstat(conn, path, sbufp) != 0) {
+       if (VFS_LSTAT(conn, path, sbufp) != 0) {
                DEBUG(5,("is_msdfs_link: %s does not exist.\n",path));
                return False;
        }
   
        if (S_ISLNK(sbufp->st_mode)) {
                /* open the link and read it */
-               referral_len = conn->vfs_ops.readlink(conn, path, referral, 
+               referral_len = VFS_READLINK(conn, path, referral, 
                                                      sizeof(pstring));
                if (referral_len == -1) {
                        DEBUG(0,("is_msdfs_link: Error reading msdfs link %s: %s\n", path, strerror(errno)));
@@ -785,10 +785,10 @@ BOOL create_msdfs_link(struct junction_map* jn, BOOL exists)
        DEBUG(5,("create_msdfs_link: Creating new msdfs link: %s -> %s\n", path, msdfs_link));
 
        if(exists)
-               if(conn->vfs_ops.unlink(conn,path)!=0)
+               if(VFS_UNLINK(conn,path)!=0)
                        return False;
 
-       if(conn->vfs_ops.symlink(conn, msdfs_link, path) < 0) {
+       if(VFS_SYMLINK(conn, msdfs_link, path) < 0) {
                DEBUG(1,("create_msdfs_link: symlink failed %s -> %s\nError: %s\n", 
                                path, msdfs_link, strerror(errno)));
                return False;
@@ -805,7 +805,7 @@ BOOL remove_msdfs_link(struct junction_map* jn)
        if(!junction_to_local_path(jn, path, sizeof(path), conn))
                return False;
      
-       if(conn->vfs_ops.unlink(conn, path)!=0)
+       if(VFS_UNLINK(conn, path)!=0)
                return False;
   
        return True;
@@ -862,7 +862,7 @@ static BOOL form_junctions(int snum, struct junction_map* jn, int* jn_count)
        cnt++;
        
        /* Now enumerate all dfs links */
-       dirp = conn->vfs_ops.opendir(conn, connect_path);
+       dirp = VFS_OPENDIR(conn, connect_path);
        if(!dirp)
                return False;
 
@@ -881,7 +881,7 @@ static BOOL form_junctions(int snum, struct junction_map* jn, int* jn_count)
                }
        }
        
-       conn->vfs_ops.closedir(conn,dirp);
+       VFS_CLOSEDIR(conn,dirp);
        *jn_count = cnt;
        return True;
 }
index 7ffe1244ba1e77f29ab6df21be030a1428395f7b..eee23a39b64a8adcb3ae2727aecd905864e438be 100644 (file)
@@ -336,9 +336,7 @@ typedef struct
        char **printer_admin;
        char *volume;
        char *fstype;
-       char **szVfsObjectFile;
-       char *szVfsOptions;
-       char *szVfsPath;
+       char **szVfsObjects;
        char *szMSDfsProxy;
        int iMinPrintSpace;
        int iMaxPrintJobs;
@@ -457,9 +455,7 @@ static service sDefault = {
        NULL,                   /* printer admin */
        NULL,                   /* volume */
        NULL,                   /* fstype */
-       NULL,                   /* vfs object */
-       NULL,                   /* vfs options */
-       NULL,                   /* vfs path */
+       NULL,                   /* vfs objects */
        NULL,                   /* szMSDfsProxy */
        0,                      /* iMinPrintSpace */
        1000,                   /* iMaxPrintJobs */
@@ -1102,10 +1098,9 @@ static struct parm_struct parm_table[] = {
        {"hide local users", P_BOOL, P_GLOBAL, &Globals.bHideLocalUsers, NULL, NULL, FLAG_ADVANCED | FLAG_DEVELOPER},
 
        {"VFS module options", P_SEP, P_SEPARATOR},
-       
-       {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjectFile, NULL, NULL, FLAG_SHARE},
-       {"vfs options", P_STRING, P_LOCAL, &sDefault.szVfsOptions, NULL, NULL, FLAG_SHARE},
-       {"vfs path", P_STRING, P_LOCAL, &sDefault.szVfsPath, NULL, NULL, FLAG_SHARE},
+
+       {"vfs objects", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_SHARE},
+       {"vfs object", P_LIST, P_LOCAL, &sDefault.szVfsObjects, NULL, NULL, FLAG_SHARE | FLAG_HIDE},
 
        
        {"msdfs root", P_BOOL, P_LOCAL, &sDefault.bMSDfsRoot, NULL, NULL, FLAG_SHARE},
@@ -1770,9 +1765,7 @@ FN_LOCAL_LIST(lp_readlist, readlist)
 FN_LOCAL_LIST(lp_writelist, writelist)
 FN_LOCAL_LIST(lp_printer_admin, printer_admin)
 FN_LOCAL_STRING(lp_fstype, fstype)
-FN_LOCAL_LIST(lp_vfsobj, szVfsObjectFile)
-FN_LOCAL_STRING(lp_vfs_options, szVfsOptions)
-FN_LOCAL_STRING(lp_vfs_path, szVfsPath)
+FN_LOCAL_LIST(lp_vfs_objects, szVfsObjects)
 FN_LOCAL_STRING(lp_msdfs_proxy, szMSDfsProxy)
 static FN_LOCAL_STRING(lp_volume, volume)
 FN_LOCAL_STRING(lp_mangled_map, szMangledMap)
index b9aed03c961cdbc790743e6c9742964b1f4c4d8a..070efc2286cefaff06655460c1ede4e45fcee660 100644 (file)
@@ -746,7 +746,7 @@ static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32
        }
 
        /* Skip OEM header (if any) and the DOS stub to start of Windows header */
-       if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
+       if (VFS_LSEEK(fsp, fsp->fd, SVAL(buf,DOS_HEADER_LFANEW_OFFSET), SEEK_SET) == (SMB_OFF_T)-1) {
                DEBUG(3,("get_file_version: File [%s] too short, errno = %d\n",
                                fname, errno));
                /* Assume this isn't an error... the file just looks sort of like a PE/NE file */
@@ -806,7 +806,7 @@ static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32
                                }
 
                                /* Seek to the start of the .rsrc section info */
-                               if (fsp->conn->vfs_ops.lseek(fsp, fsp->fd, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
+                               if (VFS_LSEEK(fsp, fsp->fd, section_pos, SEEK_SET) == (SMB_OFF_T)-1) {
                                        DEBUG(3,("get_file_version: PE file [%s] too short for section info, errno = %d\n",
                                                        fname, errno));
                                        goto error_exit;
@@ -899,7 +899,7 @@ static int get_file_version(files_struct *fsp, char *fname,uint32 *major, uint32
                                 * twice, as it is simpler to read the code. */
                                if (strcmp(&buf[i], VS_SIGNATURE) == 0) {
                                        /* Compute skip alignment to next long address */
-                                       int skip = -(fsp->conn->vfs_ops.lseek(fsp, fsp->fd, 0, SEEK_CUR) - (byte_count - i) +
+                                       int skip = -(VFS_LSEEK(fsp, fsp->fd, 0, SEEK_CUR) - (byte_count - i) +
                                                                 sizeof(VS_SIGNATURE)) & 3;
                                        if (IVAL(buf,i+sizeof(VS_SIGNATURE)+skip) != 0xfeef04bd) continue;
 
@@ -992,7 +992,7 @@ static int file_version_is_newer(connection_struct *conn, fstring new_file, fstr
                        DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
                                         old_file));
                        use_version = False;
-                       if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
+                       if (VFS_FSTAT(fsp, fsp->fd, &st) == -1) goto error_exit;
                        old_create_time = st.st_mtime;
                        DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", old_create_time));
                }
@@ -1021,7 +1021,7 @@ static int file_version_is_newer(connection_struct *conn, fstring new_file, fstr
                        DEBUG(6,("file_version_is_newer: Version info not found [%s], use mod time\n",
                                         new_file));
                        use_version = False;
-                       if (fsp->conn->vfs_ops.fstat(fsp, fsp->fd, &st) == -1) goto error_exit;
+                       if (VFS_FSTAT(fsp, fsp->fd, &st) == -1) goto error_exit;
                        new_create_time = st.st_mtime;
                        DEBUGADD(6,("file_version_is_newer: mod time = %ld sec\n", new_create_time));
                }
index 45d937f29c40b9c1370f4aed62df397d8724bfc8..00a707b34e0d009fbe3276ba6ce14c2dd72956aa 100644 (file)
@@ -80,7 +80,7 @@ files_struct *print_fsp_open(connection_struct *conn, char *fname)
        string_set(&fsp->fsp_name,print_job_fname(SNUM(conn),jobid));
        fsp->wbmpx_ptr = NULL;      
        fsp->wcp = NULL; 
-       conn->vfs_ops.fstat(fsp,fsp->fd, &sbuf);
+       VFS_FSTAT(fsp,fsp->fd, &sbuf);
        fsp->mode = sbuf.st_mode;
        fsp->inode = sbuf.st_ino;
        fsp->dev = sbuf.st_dev;
index 1a7b64858b5992301d19488f95ca7bd8a1e60878..6a6391f6aded2792199b4bb4da2997565ad4799b 100644 (file)
@@ -1887,7 +1887,7 @@ WERROR _srv_net_file_query_secdesc(pipes_struct *p, SRV_Q_NET_FILE_QUERY_SECDESC
                }
        }
 
-       sd_size = conn->vfs_ops.get_nt_acl(fsp, fsp->fsp_name, &psd);
+       sd_size = VFS_GET_NT_ACL(fsp, fsp->fsp_name, &psd);
 
        if (sd_size == 0) {
                DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", filename));
@@ -1991,7 +1991,7 @@ WERROR _srv_net_file_set_secdesc(pipes_struct *p, SRV_Q_NET_FILE_SET_SECDESC *q_
                }
        }
 
-       ret = conn->vfs_ops.set_nt_acl(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
+       ret = VFS_SET_NT_ACL(fsp, fsp->fsp_name, q_u->sec_info, q_u->sec_desc);
 
        if (ret == False) {
                DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", filename));
index 5cca85500fd831dbf0d1e8688494cbdfe9ce1a8a..a5d74cedb1e3e339de2fc97d62286eaad4ace568 100644 (file)
@@ -185,7 +185,7 @@ static int close_normal_file(files_struct *fsp, BOOL normal_close)
        if (normal_close && delete_on_close) {
                DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n",
                        fsp->fsp_name));
-               if(fsp->conn->vfs_ops.unlink(conn,fsp->fsp_name) != 0) {
+               if(VFS_UNLINK(conn,fsp->fsp_name) != 0) {
                        /*
                         * This call can potentially fail as another smbd may have
                         * had the file open with delete on close set and deleted
index b6c7aa1076e3bd47bbe70a50a0b6e297da92be36..eb2d2bbcbf2da2089b8563ba9f0bd9d00b8794b3 100644 (file)
@@ -93,6 +93,7 @@ thinking the server is still available.
 ****************************************************************************/
 connection_struct *conn_new(void)
 {
+       TALLOC_CTX *mem_ctx;
        connection_struct *conn;
        int i;
 
@@ -103,10 +104,16 @@ connection_struct *conn_new(void)
                return NULL;
        }
 
-       conn = (connection_struct *)malloc(sizeof(*conn));
-       if (!conn) return NULL;
+       if ((mem_ctx=talloc_init("connection_struct"))==NULL) {
+               DEBUG(0,("talloc_init(connection_struct) failed!\n"));
+               return NULL;
+       }
 
-       ZERO_STRUCTP(conn);
+       if ((conn=(connection_struct *)talloc_zero(mem_ctx, sizeof(*conn)))==NULL) {
+               DEBUG(0,("talloc_zero() failed!\n"));
+               return NULL;
+       }
+       conn->mem_ctx = mem_ctx;
        conn->cnum = i;
 
        bitmap_set(bmap, i);
@@ -195,27 +202,16 @@ void conn_clear_vuid_cache(uint16 vuid)
 
 void conn_free(connection_struct *conn)
 {
-       smb_vfs_handle_struct *handle, *thandle;
-       void (*done_fptr)(connection_struct *the_conn);
+       vfs_handle_struct *handle = NULL, *thandle = NULL;
+       TALLOC_CTX *mem_ctx = NULL;
 
        /* Free vfs_connection_struct */
-       handle = conn->vfs_private;
+       handle = conn->vfs_handles;
        while(handle) {
-               /* Only call dlclose for the old modules */
-               if (handle->handle) {
-                       /* Close dlopen() handle */
-                       done_fptr = (void (*)(connection_struct *))sys_dlsym(handle->handle, "vfs_done");
-
-                       if (done_fptr == NULL) {
-                               DEBUG(3, ("No vfs_done() symbol found in module with handle %p, ignoring\n", handle->handle));
-                       } else {
-                               done_fptr(conn);
-                       }
-                       sys_dlclose(handle->handle);
-               }
-               DLIST_REMOVE(conn->vfs_private, handle);
+               DLIST_REMOVE(conn->vfs_handles, handle);
                thandle = handle->next;
-               SAFE_FREE(handle);
+               if (handle->free_data)
+                       handle->free_data(&handle->data);
                handle = thandle;
        }
 
@@ -238,8 +234,9 @@ void conn_free(connection_struct *conn)
        bitmap_clear(bmap, conn->cnum);
        num_open--;
 
+       mem_ctx = conn->mem_ctx;
        ZERO_STRUCTP(conn);
-       SAFE_FREE(conn);
+       talloc_destroy(mem_ctx);
 }
 
 
index 6cf56fd373bb0089ea1a438de7c10ff8ad7163df..48ddf86837377095ff45158d01a3aa59e37a13fd 100644 (file)
@@ -643,7 +643,7 @@ BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype, pstring fname
                        pstrcpy(pathreal,path);
                        pstrcat(path,fname);
                        pstrcat(pathreal,dname);
-                       if (conn->vfs_ops.stat(conn, pathreal, &sbuf) != 0) {
+                       if (VFS_STAT(conn, pathreal, &sbuf) != 0) {
                                DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
                                continue;
                        }
@@ -700,7 +700,7 @@ static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_S
                return True;
 
        /* If we can't stat it does not show it */
-       if (!VALID_STAT(*pst) && (vfs_stat(conn, name, pst) != 0))
+       if (!VALID_STAT(*pst) && (VFS_STAT(conn, name, pst) != 0))
                return False;
 
        /* Pseudo-open the file (note - no fd's created). */
@@ -715,7 +715,7 @@ static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_S
                return False;
 
        /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
-       sd_size = conn->vfs_ops.fget_nt_acl(fsp, fsp->fd, &psd);
+       sd_size = VFS_FGET_NT_ACL(fsp, fsp->fd, &psd);
        close_file(fsp, True);
 
        /* No access if SD get failed. */
@@ -753,7 +753,7 @@ static BOOL user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_
                return True;
 
        /* If we can't stat it does not show it */
-       if (!VALID_STAT(*pst) && (vfs_stat(conn, name, pst) != 0))
+       if (!VALID_STAT(*pst) && (VFS_STAT(conn, name, pst) != 0))
                return False;
 
        /* Pseudo-open the file (note - no fd's created). */
@@ -768,7 +768,7 @@ static BOOL user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_
                return False;
 
        /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
-       sd_size = conn->vfs_ops.fget_nt_acl(fsp, fsp->fd, &psd);
+       sd_size = VFS_FGET_NT_ACL(fsp, fsp->fd, &psd);
        close_file(fsp, False);
 
        /* No access if SD get failed. */
@@ -794,7 +794,7 @@ static BOOL file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT
                return True;
 
        /* If we can't stat it does not show it */
-       if (!VALID_STAT(*pst) && (vfs_stat(conn, name, pst) != 0))
+       if (!VALID_STAT(*pst) && (VFS_STAT(conn, name, pst) != 0))
                return True;
 
        if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
@@ -811,7 +811,7 @@ void *OpenDir(connection_struct *conn, const char *name, BOOL use_veto)
 {
        Dir *dirp;
        const char *n;
-       DIR *p = conn->vfs_ops.opendir(conn,name);
+       DIR *p = VFS_OPENDIR(conn,name);
        int used=0;
 
        if (!p)
@@ -819,7 +819,7 @@ void *OpenDir(connection_struct *conn, const char *name, BOOL use_veto)
        dirp = (Dir *)malloc(sizeof(Dir));
        if (!dirp) {
                DEBUG(0,("Out of memory in OpenDir\n"));
-               conn->vfs_ops.closedir(conn,p);
+               VFS_CLOSEDIR(conn,p);
                return(NULL);
        }
        dirp->pos = dirp->numentries = dirp->mallocsize = 0;
@@ -912,7 +912,7 @@ void *OpenDir(connection_struct *conn, const char *name, BOOL use_veto)
                dirp->numentries++;
        }
 
-       conn->vfs_ops.closedir(conn,p);
+       VFS_CLOSEDIR(conn,p);
        return((void *)dirp);
 }
 
index 6c21dc04d0fba305ea4ababe7a65ab6ac4bc12d4..6365db8f1eadd995d2d1943a1a5ba9d664eb2883 100644 (file)
@@ -56,7 +56,7 @@ mode_t unix_mode(connection_struct *conn,int dosmode,const char *fname)
 
     dname = parent_dirname(fname);
     DEBUG(2,("unix_mode(%s) inheriting from %s\n",fname,dname));
-    if (vfs_stat(conn,dname,&sbuf) != 0) {
+    if (VFS_STAT(conn,dname,&sbuf) != 0) {
       DEBUG(4,("unix_mode(%s) failed, [dir %s]: %s\n",fname,dname,strerror(errno)));
       return(0);      /* *** shouldn't happen! *** */
     }
@@ -191,7 +191,7 @@ int file_chmod(connection_struct *conn,char *fname, uint32 dosmode,SMB_STRUCT_ST
 
        if (!st) {
                st = &st1;
-               if (vfs_stat(conn,fname,st))
+               if (VFS_STAT(conn,fname,st))
                        return(-1);
        }
 
@@ -235,7 +235,7 @@ int file_chmod(connection_struct *conn,char *fname, uint32 dosmode,SMB_STRUCT_ST
                unixmode |= (st->st_mode & (S_IWUSR|S_IWGRP|S_IWOTH));
        }
 
-       if ((ret = vfs_chmod(conn,fname,unixmode)) == 0)
+       if ((ret = VFS_CHMOD(conn,fname,unixmode)) == 0)
                return 0;
 
        if((errno != EPERM) && (errno != EACCES))
@@ -262,7 +262,7 @@ int file_chmod(connection_struct *conn,char *fname, uint32 dosmode,SMB_STRUCT_ST
                if (!fsp)
                        return -1;
                become_root();
-               ret = conn->vfs_ops.fchmod(fsp, fsp->fd, unixmode);
+               ret = VFS_FCHMOD(fsp, fsp->fd, unixmode);
                unbecome_root();
                close_file_fchmod(fsp);
        }
@@ -283,7 +283,7 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
 
   errno = 0;
 
-  if(conn->vfs_ops.utime(conn,fname, times) == 0)
+  if(VFS_UTIME(conn,fname, times) == 0)
     return 0;
 
   if((errno != EPERM) && (errno != EACCES))
@@ -298,7 +298,7 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
      (as DOS does).
    */
 
-  if(vfs_stat(conn,fname,&sb) != 0)
+  if(VFS_STAT(conn,fname,&sb) != 0)
     return -1;
 
   /* Check if we have write access. */
@@ -311,7 +311,7 @@ int file_utime(connection_struct *conn, char *fname, struct utimbuf *times)
                         current_user.ngroups,current_user.groups)))) {
                  /* We are allowed to become root and change the filetime. */
                  become_root();
-                 ret = conn->vfs_ops.utime(conn,fname, times);
+                 ret = VFS_UTIME(conn,fname, times);
                  unbecome_root();
          }
   }
index b612b1a45149fd65b8b4ae51136d2775e4322866..5021f54fb460f58237067de639a919ee49fd415a 100644 (file)
@@ -32,7 +32,7 @@ static SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
 {
        SMB_OFF_T seek_ret;
 
-       seek_ret = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,pos,SEEK_SET);
+       seek_ret = VFS_LSEEK(fsp,fsp->fd,pos,SEEK_SET);
 
        if(seek_ret == -1) {
                DEBUG(0,("seek_file: (%s) sys_lseek failed. Error was %s\n",
@@ -101,7 +101,7 @@ ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
 #ifdef DMF_FIX
                int numretries = 3;
 tryagain:
-               readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
+               readret = VFS_READ(fsp,fsp->fd,data,n);
                if (readret == -1) {
                        if ((errno == EAGAIN) && numretries) {
                                DEBUG(3,("read_file EAGAIN retry in 10 seconds\n"));
@@ -112,7 +112,7 @@ tryagain:
                        return -1;
                }
 #else /* NO DMF fix. */
-               readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
+               readret = VFS_READ(fsp,fsp->fd,data,n);
                if (readret == -1)
                        return -1;
 #endif
@@ -181,7 +181,7 @@ ssize_t write_file(files_struct *fsp, char *data, SMB_OFF_T pos, size_t n)
                SMB_STRUCT_STAT st;
                fsp->modified = True;
 
-               if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&st) == 0) {
+               if (VFS_FSTAT(fsp,fsp->fd,&st) == 0) {
                        int dosmode = dos_mode(fsp->conn,fsp->fsp_name,&st);
                        fsp->size = (SMB_BIG_UINT)st.st_size;
                        if (MAP_ARCHIVE(fsp->conn) && !IS_DOS_ARCHIVE(dosmode))
@@ -760,7 +760,7 @@ void sync_file(connection_struct *conn, files_struct *fsp)
 {
        if(lp_strict_sync(SNUM(conn)) && fsp->fd != -1) {
                flush_write_cache(fsp, SYNC_FLUSH);
-               conn->vfs_ops.fsync(fsp,fsp->fd);
+               VFS_FSYNC(fsp,fsp->fd);
        }
 }
 
@@ -772,7 +772,7 @@ void sync_file(connection_struct *conn, files_struct *fsp)
 int fsp_stat(files_struct *fsp, SMB_STRUCT_STAT *pst)
 {
        if (fsp->fd == -1)
-               return vfs_stat(fsp->conn, fsp->fsp_name, pst);
+               return VFS_STAT(fsp->conn, fsp->fsp_name, pst);
        else
-               return vfs_fstat(fsp,fsp->fd, pst);
+               return VFS_FSTAT(fsp,fsp->fd, pst);
 }
index b9e33e8f934316cc3da7e471ea5b398ec41f3970..6622a6ba63e9ecfe6475099d8019eb07133bd43a 100644 (file)
@@ -178,7 +178,7 @@ BOOL unix_convert(pstring name,connection_struct *conn,char *saved_last_componen
         * stat the name - if it exists then we are all done!
         */
 
-       if (vfs_stat(conn,name,&st) == 0) {
+       if (VFS_STAT(conn,name,&st) == 0) {
                stat_cache_add(orig_path, name);
                DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
                *pst = st;
@@ -234,7 +234,7 @@ BOOL unix_convert(pstring name,connection_struct *conn,char *saved_last_componen
                 * Check if the name exists up to this point.
                 */
 
-               if (vfs_stat(conn,name, &st) == 0) {
+               if (VFS_STAT(conn,name, &st) == 0) {
                        /*
                         * It exists. it must either be a directory or this must be
                         * the last part of the path for it to be OK.
@@ -342,7 +342,7 @@ BOOL unix_convert(pstring name,connection_struct *conn,char *saved_last_componen
                                 * JRA.
                                 */
 
-                               if (vfs_stat(conn,name, &st) == 0) {
+                               if (VFS_STAT(conn,name, &st) == 0) {
                                        *pst = st;
                                } else {
                                        ZERO_STRUCT(st);
@@ -418,7 +418,7 @@ BOOL check_name(pstring name,connection_struct *conn)
 #ifdef S_ISLNK
        if (!lp_symlinks(SNUM(conn))) {
                SMB_STRUCT_STAT statbuf;
-               if ( (conn->vfs_ops.lstat(conn,name,&statbuf) != -1) &&
+               if ( (VFS_LSTAT(conn,name,&statbuf) != -1) &&
                                (S_ISLNK(statbuf.st_mode)) ) {
                        DEBUG(3,("check_name: denied: file path name %s is a symlink\n",name));
                        ret=0; 
index d8b35462acb891df1eb06c0ec1630c16b2e5ec70..913a4973f8d4dca6ce57f73c8983c9cd3a885437 100644 (file)
@@ -48,7 +48,7 @@ static BOOL notify_hash(connection_struct *conn, char *path, uint32 flags,
 
        ZERO_STRUCTP(data);
 
-       if(vfs_stat(conn,path, &st) == -1)
+       if(VFS_STAT(conn,path, &st) == -1)
                return False;
 
        data->modify_time = st.st_mtime;
@@ -100,7 +100,7 @@ static BOOL notify_hash(connection_struct *conn, char *path, uint32 flags,
                /*
                 * Do the stat - but ignore errors.
                 */             
-               vfs_stat(conn,full_name, &st);
+               VFS_STAT(conn,full_name, &st);
 
                /*
                 * Always sum the times.
index 9f7fabb75e44225942db0936926e2c6dedeb8d95..38de5586ea9e7d3249a130748ee5c178d59fe0bb 100644 (file)
@@ -1032,7 +1032,7 @@ static NTSTATUS set_sd(files_struct *fsp, char *data, uint32 sd_len, uint32 secu
        if (psd->off_dacl==0)
                security_info_sent &= ~DACL_SECURITY_INFORMATION;
        
-       ret = fsp->conn->vfs_ops.fset_nt_acl( fsp, fsp->fd, security_info_sent, psd);
+       ret = VFS_FSET_NT_ACL( fsp, fsp->fd, security_info_sent, psd);
        
        if (!ret) {
                talloc_destroy(mem_ctx);
@@ -1561,7 +1561,7 @@ static int call_nt_transact_query_security_desc(connection_struct *conn,
        if (!lp_nt_acl_support(SNUM(conn)))
                sd_size = get_null_nt_acl(mem_ctx, &psd);
        else
-               sd_size = conn->vfs_ops.fget_nt_acl(fsp, fsp->fd, &psd);
+               sd_size = VFS_FGET_NT_ACL(fsp, fsp->fd, &psd);
 
        if (sd_size == 0) {
                talloc_destroy(mem_ctx);
index 906c4b40d9f70a3fb74f97bb4288d193122e1a0c..412a0dfc504151ab8a2acc3c6ee5f5288a2259d3 100644 (file)
@@ -38,13 +38,13 @@ static int fd_open(struct connection_struct *conn, char *fname,
                flags |= O_NOFOLLOW;
 #endif
 
-       fd = conn->vfs_ops.open(conn,fname,flags,mode);
+       fd = VFS_OPEN(conn,fname,flags,mode);
 
        /* Fix for files ending in '.' */
        if((fd == -1) && (errno == ENOENT) &&
           (strchr_m(fname,'.')==NULL)) {
                pstrcat(fname,".");
-               fd = conn->vfs_ops.open(conn,fname,flags,mode);
+               fd = VFS_OPEN(conn,fname,flags,mode);
        }
 
        DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
@@ -186,9 +186,9 @@ static BOOL open_file(files_struct *fsp,connection_struct *conn,
                int ret;
 
                if (fsp->fd == -1)
-                       ret = vfs_stat(conn, fname, psbuf);
+                       ret = VFS_STAT(conn, fname, psbuf);
                else {
-                       ret = vfs_fstat(fsp,fsp->fd,psbuf);
+                       ret = VFS_FSTAT(fsp,fsp->fd,psbuf);
                        /* If we have an fd, this stat should succeed. */
                        if (ret == -1)
                                DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
@@ -259,7 +259,7 @@ static int truncate_unless_locked(struct connection_struct *conn, files_struct *
                unix_ERR_ntstatus = dos_to_ntstatus(ERRDOS, ERRlock);
                return -1;
        } else {
-               return conn->vfs_ops.ftruncate(fsp,fsp->fd,0); 
+               return VFS_FTRUNCATE(fsp,fsp->fd,0); 
        }
 }
 
@@ -1071,7 +1071,7 @@ flags=0x%X flags2=0x%X mode=0%o returned %d\n",
                /*
                 * We are modifing the file after open - update the stat struct..
                 */
-               if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
+               if ((truncate_unless_locked(conn,fsp) == -1) || (VFS_FSTAT(fsp,fsp->fd,psbuf)==-1)) {
                        unlock_share_entry_fsp(fsp);
                        fd_close(conn,fsp);
                        file_free(fsp);
@@ -1146,11 +1146,11 @@ flags=0x%X flags2=0x%X mode=0%o returned %d\n",
         * selected.
         */
 
-       if (!file_existed && !def_acl && (conn->vfs_ops.fchmod_acl != NULL)) {
+       if (!file_existed && !def_acl && (conn->vfs.ops.fchmod_acl != NULL)) {
 
                int saved_errno = errno; /* We might get ENOSYS in the next call.. */
 
-               if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
+               if (VFS_FCHMOD_ACL(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
                        errno = saved_errno; /* Ignore ENOSYS */
 
        } else if (new_mode) {
@@ -1159,9 +1159,9 @@ flags=0x%X flags2=0x%X mode=0%o returned %d\n",
 
                /* Attributes need changing. File already existed. */
 
-               if (conn->vfs_ops.fchmod_acl != NULL) {
+               if (conn->vfs.ops.fchmod_acl != NULL) {
                        int saved_errno = errno; /* We might get ENOSYS in the next call.. */
-                       ret = conn->vfs_ops.fchmod_acl(fsp, fsp->fd, new_mode);
+                       ret = VFS_FCHMOD_ACL(fsp, fsp->fd, new_mode);
 
                        if (ret == -1 && errno == ENOSYS) {
                                errno = saved_errno; /* Ignore ENOSYS */
@@ -1172,7 +1172,7 @@ flags=0x%X flags2=0x%X mode=0%o returned %d\n",
                        }
                }
 
-               if ((ret == -1) && (conn->vfs_ops.fchmod(fsp, fsp->fd, new_mode) == -1))
+               if ((ret == -1) && (VFS_FCHMOD(fsp, fsp->fd, new_mode) == -1))
                        DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
                                fname, (int)new_mode));
        }
@@ -1278,14 +1278,14 @@ files_struct *open_directory(connection_struct *conn, char *fname, SMB_STRUCT_ST
                                return NULL;
                        }
 
-                       if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
+                       if(vfs_MkDir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
                                DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
                                         fname, strerror(errno) ));
                                file_free(fsp);
                                return NULL;
                        }
 
-                       if(vfs_stat(conn,fname, psbuf) != 0) {
+                       if(VFS_STAT(conn,fname, psbuf) != 0) {
                                file_free(fsp);
                                return NULL;
                        }
index a38acc437d99c9608f2782ede2c9dc81f05864f0..34c33af473d7991c365df0ce8ddd381f245d736d 100644 (file)
@@ -158,9 +158,9 @@ static mode_t convert_permset_to_mode_t(connection_struct *conn, SMB_ACL_PERMSET
 {
        mode_t ret = 0;
 
-       ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_READ) ? S_IRUSR : 0);
-       ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_WRITE) ? S_IWUSR : 0);
-       ret |= (conn->vfs_ops.sys_acl_get_perm(conn, permset, SMB_ACL_EXECUTE) ? S_IXUSR : 0);
+       ret |= (VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_READ) ? S_IRUSR : 0);
+       ret |= (VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_WRITE) ? S_IWUSR : 0);
+       ret |= (VFS_SYS_ACL_GET_PERM(conn, permset, SMB_ACL_EXECUTE) ? S_IXUSR : 0);
 
        return ret;
 }
@@ -190,18 +190,18 @@ static mode_t unix_perms_to_acl_perms(mode_t mode, int r_mask, int w_mask, int x
 
 static int map_acl_perms_to_permset(connection_struct *conn, mode_t mode, SMB_ACL_PERMSET_T *p_permset)
 {
-       if (conn->vfs_ops.sys_acl_clear_perms(conn, *p_permset) ==  -1)
+       if (VFS_SYS_ACL_CLEAR_PERMS(conn, *p_permset) ==  -1)
                return -1;
        if (mode & S_IRUSR) {
-               if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_READ) == -1)
+               if (VFS_SYS_ACL_ADD_PERM(conn, *p_permset, SMB_ACL_READ) == -1)
                        return -1;
        }
        if (mode & S_IWUSR) {
-               if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_WRITE) == -1)
+               if (VFS_SYS_ACL_ADD_PERM(conn, *p_permset, SMB_ACL_WRITE) == -1)
                        return -1;
        }
        if (mode & S_IXUSR) {
-               if (conn->vfs_ops.sys_acl_add_perm(conn, *p_permset, SMB_ACL_EXECUTE) == -1)
+               if (VFS_SYS_ACL_ADD_PERM(conn, *p_permset, SMB_ACL_EXECUTE) == -1)
                        return -1;
        }
        return 0;
@@ -649,7 +649,7 @@ static BOOL ensure_canon_entry_valid(canon_ace **pp_ace,
        /*
         * When setting ACLs and missing one out of SMB_ACL_USER_OBJ,
         * SMB_ACL_GROUP_OBJ, SMB_ACL_OTHER, try to retrieve current
-        * values. For user and other a simple vfs_stat would do, but
+        * values. For user and other a simple VFS_STAT would do, but
         * we would get mask instead of group. Let's do it via ACL.
         */
 
@@ -659,13 +659,13 @@ static BOOL ensure_canon_entry_valid(canon_ace **pp_ace,
                int entry_id = SMB_ACL_FIRST_ENTRY;
 
                if(fsp->is_directory || fsp->fd == -1) {
-                       current_posix_acl = conn->vfs_ops.sys_acl_get_file(conn, fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
+                       current_posix_acl = VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
                } else {
-                       current_posix_acl = conn->vfs_ops.sys_acl_get_fd(fsp, fsp->fd);
+                       current_posix_acl = VFS_SYS_ACL_GET_FD(fsp, fsp->fd);
                }
 
                if (current_posix_acl) {
-                       while (conn->vfs_ops.sys_acl_get_entry(conn, current_posix_acl, entry_id, &entry) == 1) {
+                       while (VFS_SYS_ACL_GET_ENTRY(conn, current_posix_acl, entry_id, &entry) == 1) {
                                SMB_ACL_TAG_T tagtype;
                                SMB_ACL_PERMSET_T permset;
 
@@ -674,10 +674,10 @@ static BOOL ensure_canon_entry_valid(canon_ace **pp_ace,
                                        entry_id = SMB_ACL_NEXT_ENTRY;
 
                                /* Is this a MASK entry ? */
-                               if (conn->vfs_ops.sys_acl_get_tag_type(conn, entry, &tagtype) == -1)
+                               if (VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1)
                                        continue;
 
-                               if (conn->vfs_ops.sys_acl_get_permset(conn, entry, &permset) == -1)
+                               if (VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1)
                                        continue;
 
                                switch(tagtype) {
@@ -695,7 +695,7 @@ static BOOL ensure_canon_entry_valid(canon_ace **pp_ace,
                                                break;
                                }
                        }
-                       conn->vfs_ops.sys_acl_free_acl(conn, current_posix_acl);
+                       VFS_SYS_ACL_FREE_ACL(conn, current_posix_acl);
                } else {
                        DEBUG(10,("ensure_canon_entry_valid: failed to retrieve current ACL of %s\n",
                                fsp->fsp_name));
@@ -1658,7 +1658,7 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
        SMB_ACL_ENTRY_T entry;
        size_t ace_count;
 
-       while ( posix_acl && (conn->vfs_ops.sys_acl_get_entry(conn, posix_acl, entry_id, &entry) == 1)) {
+       while ( posix_acl && (VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1)) {
                SMB_ACL_TAG_T tagtype;
                SMB_ACL_PERMSET_T permset;
                DOM_SID sid;
@@ -1670,10 +1670,10 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
                        entry_id = SMB_ACL_NEXT_ENTRY;
 
                /* Is this a MASK entry ? */
-               if (conn->vfs_ops.sys_acl_get_tag_type(conn, entry, &tagtype) == -1)
+               if (VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1)
                        continue;
 
-               if (conn->vfs_ops.sys_acl_get_permset(conn, entry, &permset) == -1)
+               if (VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1)
                        continue;
 
                /* Decide which SID to use based on the ACL type. */
@@ -1686,7 +1686,7 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
                                break;
                        case SMB_ACL_USER:
                                {
-                                       uid_t *puid = (uid_t *)conn->vfs_ops.sys_acl_get_qualifier(conn, entry);
+                                       uid_t *puid = (uid_t *)VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
                                        if (puid == NULL) {
                                                DEBUG(0,("canonicalise_acl: Failed to get uid.\n"));
                                                continue;
@@ -1703,7 +1703,7 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
                                        uid_to_sid( &sid, *puid);
                                        unix_ug.uid = *puid;
                                        owner_type = UID_ACE;
-                                       conn->vfs_ops.sys_acl_free_qualifier(conn, (void *)puid,tagtype);
+                                       VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)puid,tagtype);
                                        break;
                                }
                        case SMB_ACL_GROUP_OBJ:
@@ -1714,7 +1714,7 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
                                break;
                        case SMB_ACL_GROUP:
                                {
-                                       gid_t *pgid = (gid_t *)conn->vfs_ops.sys_acl_get_qualifier(conn, entry);
+                                       gid_t *pgid = (gid_t *)VFS_SYS_ACL_GET_QUALIFIER(conn, entry);
                                        if (pgid == NULL) {
                                                DEBUG(0,("canonicalise_acl: Failed to get gid.\n"));
                                                continue;
@@ -1722,7 +1722,7 @@ static canon_ace *canonicalise_acl( files_struct *fsp, SMB_ACL_T posix_acl, SMB_
                                        gid_to_sid( &sid, *pgid);
                                        unix_ug.gid = *pgid;
                                        owner_type = GID_ACE;
-                                       conn->vfs_ops.sys_acl_free_qualifier(conn, (void *)pgid,tagtype);
+                                       VFS_SYS_ACL_FREE_QUALIFIER(conn, (void *)pgid,tagtype);
                                        break;
                                }
                        case SMB_ACL_MASK:
@@ -1807,7 +1807,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
 {
        connection_struct *conn = fsp->conn;
        BOOL ret = False;
-       SMB_ACL_T the_acl = conn->vfs_ops.sys_acl_init(conn, (int)count_canon_ace_list(the_ace) + 1);
+       SMB_ACL_T the_acl = VFS_SYS_ACL_INIT(conn, (int)count_canon_ace_list(the_ace) + 1);
        canon_ace *p_ace;
        int i;
        SMB_ACL_ENTRY_T mask_entry;
@@ -1865,7 +1865,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                 * Get the entry for this ACE.
                 */
 
-               if (conn->vfs_ops.sys_acl_create_entry(conn, &the_acl, &the_entry) == -1) {
+               if (VFS_SYS_ACL_CREATE_ENTRY(conn, &the_acl, &the_entry) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to create entry %d. (%s)\n",
                                i, strerror(errno) ));
                        goto done;
@@ -1891,7 +1891,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                 * First tell the entry what type of ACE this is.
                 */
 
-               if (conn->vfs_ops.sys_acl_set_tag_type(conn, the_entry, p_ace->type) == -1) {
+               if (VFS_SYS_ACL_SET_TAG_TYPE(conn, the_entry, p_ace->type) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to set tag type on entry %d. (%s)\n",
                                i, strerror(errno) ));
                        goto done;
@@ -1903,7 +1903,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                 */
 
                if ((p_ace->type == SMB_ACL_USER) || (p_ace->type == SMB_ACL_GROUP)) {
-                       if (conn->vfs_ops.sys_acl_set_qualifier(conn, the_entry,(void *)&p_ace->unix_ug.uid) == -1) {
+                       if (VFS_SYS_ACL_SET_QUALIFIER(conn, the_entry,(void *)&p_ace->unix_ug.uid) == -1) {
                                DEBUG(0,("set_canon_ace_list: Failed to set qualifier on entry %d. (%s)\n",
                                        i, strerror(errno) ));
                                goto done;
@@ -1914,7 +1914,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                 * Convert the mode_t perms in the canon_ace to a POSIX permset.
                 */
 
-               if (conn->vfs_ops.sys_acl_get_permset(conn, the_entry, &the_permset) == -1) {
+               if (VFS_SYS_ACL_GET_PERMSET(conn, the_entry, &the_permset) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to get permset on entry %d. (%s)\n",
                                i, strerror(errno) ));
                        goto done;
@@ -1930,7 +1930,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                 * ..and apply them to the entry.
                 */
 
-               if (conn->vfs_ops.sys_acl_set_permset(conn, the_entry, the_permset) == -1) {
+               if (VFS_SYS_ACL_SET_PERMSET(conn, the_entry, the_permset) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to add permset on entry %d. (%s)\n",
                                i, strerror(errno) ));
                        goto done;
@@ -1941,17 +1941,17 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
        }
 
        if (needs_mask && !got_mask_entry) {
-               if (conn->vfs_ops.sys_acl_create_entry(conn, &the_acl, &mask_entry) == -1) {
+               if (VFS_SYS_ACL_CREATE_ENTRY(conn, &the_acl, &mask_entry) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to create mask entry. (%s)\n", strerror(errno) ));
                        goto done;
                }
 
-               if (conn->vfs_ops.sys_acl_set_tag_type(conn, mask_entry, SMB_ACL_MASK) == -1) {
+               if (VFS_SYS_ACL_SET_TAG_TYPE(conn, mask_entry, SMB_ACL_MASK) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to set tag type on mask entry. (%s)\n",strerror(errno) ));
                        goto done;
                }
 
-               if (conn->vfs_ops.sys_acl_get_permset(conn, mask_entry, &mask_permset) == -1) {
+               if (VFS_SYS_ACL_GET_PERMSET(conn, mask_entry, &mask_permset) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to get mask permset. (%s)\n", strerror(errno) ));
                        goto done;
                }
@@ -1961,7 +1961,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                        goto done;
                }
 
-               if (conn->vfs_ops.sys_acl_set_permset(conn, mask_entry, mask_permset) == -1) {
+               if (VFS_SYS_ACL_SET_PERMSET(conn, mask_entry, mask_permset) == -1) {
                        DEBUG(0,("set_canon_ace_list: Failed to add mask permset. (%s)\n", strerror(errno) ));
                        goto done;
                }
@@ -1971,7 +1971,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
         * Check if the ACL is valid.
         */
 
-       if (conn->vfs_ops.sys_acl_valid(conn, the_acl) == -1) {
+       if (VFS_SYS_ACL_VALID(conn, the_acl) == -1) {
                DEBUG(0,("set_canon_ace_list: ACL type (%s) is invalid for set (%s).\n",
                                the_acl_type == SMB_ACL_TYPE_DEFAULT ? "directory default" : "file",
                                strerror(errno) ));
@@ -1983,7 +1983,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
         */
 
        if(default_ace || fsp->is_directory || fsp->fd == -1) {
-               if (conn->vfs_ops.sys_acl_set_file(conn, fsp->fsp_name, the_acl_type, the_acl) == -1) {
+               if (VFS_SYS_ACL_SET_FILE(conn, fsp->fsp_name, the_acl_type, the_acl) == -1) {
                        /*
                         * Some systems allow all the above calls and only fail with no ACL support
                         * when attempting to apply the acl. HPUX with HFS is an example of this. JRA.
@@ -2002,7 +2002,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
                        goto done;
                }
        } else {
-               if (conn->vfs_ops.sys_acl_set_fd(fsp, fsp->fd, the_acl) == -1) {
+               if (VFS_SYS_ACL_SET_FD(fsp, fsp->fd, the_acl) == -1) {
                        /*
                         * Some systems allow all the above calls and only fail with no ACL support
                         * when attempting to apply the acl. HPUX with HFS is an example of this. JRA.
@@ -2026,7 +2026,7 @@ static BOOL set_canon_ace_list(files_struct *fsp, canon_ace *the_ace, BOOL defau
   done:
 
        if (the_acl != NULL)
-           conn->vfs_ops.sys_acl_free_acl(conn, the_acl);
+           VFS_SYS_ACL_FREE_ACL(conn, the_acl);
 
        return ret;
 }
@@ -2057,8 +2057,8 @@ SMB_ACL_T free_empty_sys_acl(connection_struct *conn, SMB_ACL_T acl)
 
        if (!acl)
                return NULL;
-       if (conn->vfs_ops.sys_acl_get_entry(conn, acl, SMB_ACL_FIRST_ENTRY, &entry) != 1) {
-               conn->vfs_ops.sys_acl_free_acl(conn, acl);
+       if (VFS_SYS_ACL_GET_ENTRY(conn, acl, SMB_ACL_FIRST_ENTRY, &entry) != 1) {
+               VFS_SYS_ACL_FREE_ACL(conn, acl);
                return NULL;
        }
        return acl;
@@ -2224,34 +2224,34 @@ size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc)
        if(fsp->is_directory || fsp->fd == -1) {
 
                /* Get the stat struct for the owner info. */
-               if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0) {
+               if(VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf) != 0) {
                        return 0;
                }
                /*
                 * Get the ACL from the path.
                 */
 
-               posix_acl = conn->vfs_ops.sys_acl_get_file(conn, fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
+               posix_acl = VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_ACCESS);
 
                /*
                 * If it's a directory get the default POSIX ACL.
                 */
 
                if(fsp->is_directory) {
-                       dir_acl = conn->vfs_ops.sys_acl_get_file(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
+                       dir_acl = VFS_SYS_ACL_GET_FILE(conn, fsp->fsp_name, SMB_ACL_TYPE_DEFAULT);
                        dir_acl = free_empty_sys_acl(conn, dir_acl);
                }
 
        } else {
 
                /* Get the stat struct for the owner info. */
-               if(vfs_fstat(fsp,fsp->fd,&sbuf) != 0) {
+               if(VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
                        return 0;
                }
                /*
                 * Get the ACL from the fd.
                 */
-               posix_acl = conn->vfs_ops.sys_acl_get_fd(fsp, fsp->fd);
+               posix_acl = VFS_SYS_ACL_GET_FD(fsp, fsp->fd);
        }
 
        DEBUG(5,("get_nt_acl : file ACL %s, directory ACL %s\n",
@@ -2479,9 +2479,9 @@ size_t get_nt_acl(files_struct *fsp, SEC_DESC **ppdesc)
  done:
 
        if (posix_acl)
-               conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
+               VFS_SYS_ACL_FREE_ACL(conn, posix_acl);
        if (dir_acl)
-               conn->vfs_ops.sys_acl_free_acl(conn, dir_acl);
+               VFS_SYS_ACL_FREE_ACL(conn, dir_acl);
        free_canon_ace_list(file_ace);
        free_canon_ace_list(dir_ace);
        SAFE_FREE(nt_ace_list);
@@ -2505,14 +2505,14 @@ static int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_
        SMB_STRUCT_STAT st;
 
        /* try the direct way first */
-       ret = vfs_chown(conn, fname, uid, gid);
+       ret = VFS_CHOWN(conn, fname, uid, gid);
        if (ret == 0)
                return 0;
 
        if(!CAN_WRITE(conn) || !lp_dos_filemode(SNUM(conn)))
                return -1;
 
-       if (vfs_stat(conn,fname,&st))
+       if (VFS_STAT(conn,fname,&st))
                return -1;
 
        fsp = open_file_fchmod(conn,fname,&st);
@@ -2527,7 +2527,7 @@ static int try_chown(connection_struct *conn, const char *fname, uid_t uid, gid_
 
        become_root();
        /* Keep the current file gid the same. */
-       ret = vfswrap_fchown(fsp, fsp->fd, uid, (gid_t)-1);
+       ret = VFS_FCHOWN(fsp, fsp->fd, uid, (gid_t)-1);
        unbecome_root();
 
        close_file_fchmod(fsp);
@@ -2570,10 +2570,10 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
         */
 
        if(fsp->is_directory || fsp->fd == -1) {
-               if(vfs_stat(fsp->conn,fsp->fsp_name, &sbuf) != 0)
+               if(VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf) != 0)
                        return False;
        } else {
-               if(vfs_fstat(fsp,fsp->fd,&sbuf) != 0)
+               if(VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0)
                        return False;
        }
 
@@ -2619,7 +2619,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
                 */
 
                if(fsp->is_directory) {
-                       if(vfs_stat(fsp->conn, fsp->fsp_name, &sbuf) != 0) {
+                       if(VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf) != 0) {
                                return False;
                        }
                } else {
@@ -2627,9 +2627,9 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
                        int ret;
     
                        if(fsp->fd == -1)
-                               ret = vfs_stat(fsp->conn, fsp->fsp_name, &sbuf);
+                               ret = VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf);
                        else
-                               ret = vfs_fstat(fsp,fsp->fd,&sbuf);
+                               ret = VFS_FSTAT(fsp,fsp->fd,&sbuf);
   
                        if(ret != 0)
                                return False;
@@ -2697,7 +2697,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
                                         * No default ACL - delete one if it exists.
                                         */
 
-                                       if (conn->vfs_ops.sys_acl_delete_def_file(conn, fsp->fsp_name) == -1) {
+                                       if (VFS_SYS_ACL_DELETE_DEF_FILE(conn, fsp->fsp_name) == -1) {
                                                DEBUG(3,("set_nt_acl: sys_acl_delete_def_file failed (%s)\n", strerror(errno)));
                                                free_canon_ace_list(file_ace_list);
                                                free_canon_ace_list(dir_ace_list);
@@ -2726,7 +2726,7 @@ BOOL set_nt_acl(files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
                                        DEBUG(3,("set_nt_acl: chmod %s. perms = 0%o.\n",
                                                fsp->fsp_name, (unsigned int)posix_perms ));
 
-                                       if(conn->vfs_ops.chmod(conn,fsp->fsp_name, posix_perms) == -1) {
+                                       if(VFS_CHMOD(conn,fsp->fsp_name, posix_perms) == -1) {
                                                DEBUG(3,("set_nt_acl: chmod %s, 0%o failed. Error = %s.\n",
                                                                fsp->fsp_name, (unsigned int)posix_perms, strerror(errno) ));
                                                free_canon_ace_list(file_ace_list);
@@ -2768,7 +2768,7 @@ static int chmod_acl_internals( connection_struct *conn, SMB_ACL_T posix_acl, mo
        SMB_ACL_ENTRY_T entry;
        int num_entries = 0;
 
-       while ( conn->vfs_ops.sys_acl_get_entry(conn, posix_acl, entry_id, &entry) == 1) {
+       while ( VFS_SYS_ACL_GET_ENTRY(conn, posix_acl, entry_id, &entry) == 1) {
                SMB_ACL_TAG_T tagtype;
                SMB_ACL_PERMSET_T permset;
                mode_t perms;
@@ -2777,10 +2777,10 @@ static int chmod_acl_internals( connection_struct *conn, SMB_ACL_T posix_acl, mo
                if (entry_id == SMB_ACL_FIRST_ENTRY)
                        entry_id = SMB_ACL_NEXT_ENTRY;
 
-               if (conn->vfs_ops.sys_acl_get_tag_type(conn, entry, &tagtype) == -1)
+               if (VFS_SYS_ACL_GET_TAG_TYPE(conn, entry, &tagtype) == -1)
                        return -1;
 
-               if (conn->vfs_ops.sys_acl_get_permset(conn, entry, &permset) == -1)
+               if (VFS_SYS_ACL_GET_PERMSET(conn, entry, &permset) == -1)
                        return -1;
 
                num_entries++;
@@ -2811,7 +2811,7 @@ static int chmod_acl_internals( connection_struct *conn, SMB_ACL_T posix_acl, mo
                if (map_acl_perms_to_permset(conn, perms, &permset) == -1)
                        return -1;
 
-               if (conn->vfs_ops.sys_acl_set_permset(conn, entry, permset) == -1)
+               if (VFS_SYS_ACL_SET_PERMSET(conn, entry, permset) == -1)
                        return -1;
        }
 
@@ -2837,17 +2837,17 @@ static int copy_access_acl(connection_struct *conn, const char *from, const char
        SMB_ACL_T posix_acl = NULL;
        int ret = -1;
 
-       if ((posix_acl = conn->vfs_ops.sys_acl_get_file(conn, from, SMB_ACL_TYPE_ACCESS)) == NULL)
+       if ((posix_acl = VFS_SYS_ACL_GET_FILE(conn, from, SMB_ACL_TYPE_ACCESS)) == NULL)
                return -1;
 
        if ((ret = chmod_acl_internals(conn, posix_acl, mode)) == -1)
                goto done;
 
-       ret = conn->vfs_ops.sys_acl_set_file(conn, to, SMB_ACL_TYPE_ACCESS, posix_acl);
+       ret = VFS_SYS_ACL_SET_FILE(conn, to, SMB_ACL_TYPE_ACCESS, posix_acl);
 
  done:
 
-       conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
+       VFS_SYS_ACL_FREE_ACL(conn, posix_acl);
        return ret;
 }
 
@@ -2889,17 +2889,17 @@ int fchmod_acl(files_struct *fsp, int fd, mode_t mode)
        SMB_ACL_T posix_acl = NULL;
        int ret = -1;
 
-       if ((posix_acl = conn->vfs_ops.sys_acl_get_fd(fsp, fd)) == NULL)
+       if ((posix_acl = VFS_SYS_ACL_GET_FD(fsp, fd)) == NULL)
                return -1;
 
        if ((ret = chmod_acl_internals(conn, posix_acl, mode)) == -1)
                goto done;
 
-       ret = conn->vfs_ops.sys_acl_set_fd(fsp, fd, posix_acl);
+       ret = VFS_SYS_ACL_SET_FD(fsp, fd, posix_acl);
 
   done:
 
-       conn->vfs_ops.sys_acl_free_acl(conn, posix_acl);
+       VFS_SYS_ACL_FREE_ACL(conn, posix_acl);
        return ret;
 }
 
@@ -2909,14 +2909,14 @@ int fchmod_acl(files_struct *fsp, int fd, mode_t mode)
 
 BOOL directory_has_default_acl(connection_struct *conn, const char *fname)
 {
-        SMB_ACL_T dir_acl = conn->vfs_ops.sys_acl_get_file( conn, fname, SMB_ACL_TYPE_DEFAULT);
+        SMB_ACL_T dir_acl = VFS_SYS_ACL_GET_FILE( conn, fname, SMB_ACL_TYPE_DEFAULT);
         BOOL has_acl = False;
         SMB_ACL_ENTRY_T entry;
 
-        if (dir_acl != NULL && (conn->vfs_ops.sys_acl_get_entry(conn, dir_acl, SMB_ACL_FIRST_ENTRY, &entry) == 1))
+        if (dir_acl != NULL && (VFS_SYS_ACL_GET_ENTRY(conn, dir_acl, SMB_ACL_FIRST_ENTRY, &entry) == 1))
                 has_acl = True;
 
        if (dir_acl)
-               conn->vfs_ops.sys_acl_free_acl(conn, dir_acl);
+               VFS_SYS_ACL_FREE_ACL(conn, dir_acl);
         return has_acl;
 }
index 9577196bfe8fb23d7a11f798937d00e688d12887..49a9b934b02aae2cdeafa436481b75bdf9e9e8f6 100644 (file)
@@ -399,7 +399,7 @@ int reply_chkpth(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
        mode = SVAL(inbuf,smb_vwv0);
 
        if (check_name(name,conn)) {
-               if (VALID_STAT(sbuf) || vfs_stat(conn,name,&sbuf) == 0)
+               if (VALID_STAT(sbuf) || VFS_STAT(conn,name,&sbuf) == 0)
                        if (!(ok = S_ISDIR(sbuf.st_mode)))
                                errno = ENOTDIR;
        }
@@ -458,7 +458,7 @@ int reply_getatr(connection_struct *conn, char *inbuf,char *outbuf, int dum_size
        } else {
                unix_convert(fname,conn,0,&bad_path,&sbuf);
                if (check_name(fname,conn)) {
-                       if (VALID_STAT(sbuf) || vfs_stat(conn,fname,&sbuf) == 0) {
+                       if (VALID_STAT(sbuf) || VFS_STAT(conn,fname,&sbuf) == 0) {
                                mode = dos_mode(conn,fname,&sbuf);
                                size = sbuf.st_size;
                                mtime = sbuf.st_mtime;
@@ -553,7 +553,7 @@ int reply_dskattr(connection_struct *conn, char *inbuf,char *outbuf, int dum_siz
        SMB_BIG_UINT dfree,dsize,bsize;
        START_PROFILE(SMBdskattr);
 
-       conn->vfs_ops.disk_free(conn,".",True,&bsize,&dfree,&dsize);
+       VFS_DISK_FREE(conn,".",True,&bsize,&dfree,&dsize);
   
        outsize = set_message(outbuf,5,0,True);
        
@@ -1128,7 +1128,7 @@ int reply_ctemp(connection_struct *conn, char *inbuf,char *outbuf, int dum_size,
                return(UNIXERROR(ERRDOS,ERRnoaccess));
        }
 
-       vfs_stat(conn,fname,&sbuf);
+       VFS_STAT(conn,fname,&sbuf);
 
        /* Open file in dos compatibility share mode. */
        /* We should fail if file does not exist. */
@@ -1227,7 +1227,7 @@ static NTSTATUS can_delete(char *fname,connection_struct *conn, int dirtype)
        if (!CAN_WRITE(conn))
                return NT_STATUS_MEDIA_WRITE_PROTECTED;
 
-       if (conn->vfs_ops.lstat(conn,fname,&sbuf) != 0)
+       if (VFS_LSTAT(conn,fname,&sbuf) != 0)
                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 
        fmode = dos_mode(conn,fname,&sbuf);
@@ -1313,7 +1313,7 @@ NTSTATUS unlink_internals(connection_struct *conn, int dirtype, char *name)
                error = can_delete(directory,conn,dirtype);
                if (!NT_STATUS_IS_OK(error)) return error;
 
-               if (vfs_unlink(conn,directory) == 0) {
+               if (VFS_UNLINK(conn,directory) == 0) {
                        count++;
                }
        } else {
@@ -1343,7 +1343,7 @@ NTSTATUS unlink_internals(connection_struct *conn, int dirtype, char *name)
                                slprintf(fname,sizeof(fname)-1, "%s/%s",directory,dname);
                                error = can_delete(fname,conn,dirtype);
                                if (!NT_STATUS_IS_OK(error)) continue;
-                               if (vfs_unlink(conn,fname) == 0) count++;
+                               if (VFS_UNLINK(conn,fname) == 0) count++;
                                DEBUG(3,("unlink_internals: succesful unlink [%s]\n",fname));
                        }
                        CloseDir(dirptr);
@@ -1429,7 +1429,7 @@ void send_file_readbraw(connection_struct *conn, files_struct *fsp, SMB_OFF_T st
                header.length = 4;
                header.free = NULL;
 
-               if ( conn->vfs_ops.sendfile( smbd_server_fd(), fsp, fsp->fd, &header, startpos, nread) == -1) {
+               if ( VFS_SENDFILE( smbd_server_fd(), fsp, fsp->fd, &header, startpos, nread) == -1) {
                        /*
                         * Special hack for broken Linux with no 64 bit clean sendfile. If we
                         * return ENOSYS then pretend we just got a normal read.
@@ -1554,7 +1554,7 @@ int reply_readbraw(connection_struct *conn, char *inbuf, char *outbuf, int dum_s
   
                if (size < sizeneeded) {
                        SMB_STRUCT_STAT st;
-                       if (vfs_fstat(fsp,fsp->fd,&st) == 0)
+                       if (VFS_FSTAT(fsp,fsp->fd,&st) == 0)
                                size = st.st_size;
                        if (!fsp->can_write) 
                                fsp->size = size;
@@ -1723,7 +1723,7 @@ int send_file_readX(connection_struct *conn, char *inbuf,char *outbuf,int length
                SMB_STRUCT_STAT sbuf;
                DATA_BLOB header;
 
-               if(vfs_fstat(fsp,fsp->fd, &sbuf) == -1)
+               if(VFS_FSTAT(fsp,fsp->fd, &sbuf) == -1)
                        return(UNIXERROR(ERRDOS,ERRnoaccess));
 
                if (startpos > sbuf.st_size)
@@ -1750,7 +1750,7 @@ int send_file_readX(connection_struct *conn, char *inbuf,char *outbuf,int length
                header.length = data - outbuf;
                header.free = NULL;
 
-               if ( conn->vfs_ops.sendfile( smbd_server_fd(), fsp, fsp->fd, &header, startpos, smb_maxcnt) == -1) {
+               if ( VFS_SENDFILE( smbd_server_fd(), fsp, fsp->fd, &header, startpos, smb_maxcnt) == -1) {
                        /*
                         * Special hack for broken Linux with no 64 bit clean sendfile. If we
                         * return ENOSYS then pretend we just got a normal read.
@@ -2262,7 +2262,7 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int size, int
                        break;
        }
 
-       if((res = conn->vfs_ops.lseek(fsp,fsp->fd,startpos,umode)) == -1) {
+       if((res = VFS_LSEEK(fsp,fsp->fd,startpos,umode)) == -1) {
                /*
                 * Check for the special case where a seek before the start
                 * of the file sets the offset to zero. Added in the CIFS spec,
@@ -2274,7 +2274,7 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int size, int
 
                        if(umode == SEEK_CUR) {
 
-                               if((current_pos = conn->vfs_ops.lseek(fsp,fsp->fd,0,SEEK_CUR)) == -1) {
+                               if((current_pos = VFS_LSEEK(fsp,fsp->fd,0,SEEK_CUR)) == -1) {
                                        END_PROFILE(SMBlseek);
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                                }
@@ -2285,7 +2285,7 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int size, int
 
                                SMB_STRUCT_STAT sbuf;
 
-                               if(vfs_fstat(fsp,fsp->fd, &sbuf) == -1) {
+                               if(VFS_FSTAT(fsp,fsp->fd, &sbuf) == -1) {
                                        END_PROFILE(SMBlseek);
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                                }
@@ -2294,7 +2294,7 @@ int reply_lseek(connection_struct *conn, char *inbuf,char *outbuf, int size, int
                        }
  
                        if(current_pos < 0)
-                               res = conn->vfs_ops.lseek(fsp,fsp->fd,0,SEEK_SET);
+                               res = VFS_LSEEK(fsp,fsp->fd,0,SEEK_SET);
                }
 
                if(res == -1) {
@@ -2830,7 +2830,7 @@ NTSTATUS mkdir_internal(connection_struct *conn, pstring directory)
        unix_convert(directory,conn,0,&bad_path,&sbuf);
        
        if (check_name(directory, conn))
-               ret = vfs_mkdir(conn,directory,unix_mode(conn,aDIR,directory));
+               ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory));
        
        if (ret == -1) {
                NTSTATUS nterr = set_bad_path_error(errno, bad_path);
@@ -2901,7 +2901,7 @@ static BOOL recursive_rmdir(connection_struct *conn, char *directory)
                pstrcat(fullname, "/");
                pstrcat(fullname, dname);
 
-               if(conn->vfs_ops.lstat(conn,fullname, &st) != 0) {
+               if(VFS_LSTAT(conn,fullname, &st) != 0) {
                        ret = True;
                        break;
                }
@@ -2911,11 +2911,11 @@ static BOOL recursive_rmdir(connection_struct *conn, char *directory)
                                ret = True;
                                break;
                        }
-                       if(vfs_rmdir(conn,fullname) != 0) {
+                       if(VFS_RMDIR(conn,fullname) != 0) {
                                ret = True;
                                break;
                        }
-               } else if(vfs_unlink(conn,fullname) != 0) {
+               } else if(VFS_UNLINK(conn,fullname) != 0) {
                        ret = True;
                        break;
                }
@@ -2932,7 +2932,7 @@ BOOL rmdir_internals(connection_struct *conn, char *directory)
 {
        BOOL ok;
 
-       ok = (vfs_rmdir(conn,directory) == 0);
+       ok = (VFS_RMDIR(conn,directory) == 0);
        if(!ok && ((errno == ENOTEMPTY)||(errno == EEXIST)) && lp_veto_files(SNUM(conn))) {
                /* 
                 * Check to see if the only thing in this directory are
@@ -2974,21 +2974,21 @@ BOOL rmdir_internals(connection_struct *conn, char *directory)
                                        pstrcat(fullname, "/");
                                        pstrcat(fullname, dname);
                      
-                                       if(conn->vfs_ops.lstat(conn,fullname, &st) != 0)
+                                       if(VFS_LSTAT(conn,fullname, &st) != 0)
                                                break;
                                        if(st.st_mode & S_IFDIR) {
                                                if(lp_recursive_veto_delete(SNUM(conn))) {
                                                        if(recursive_rmdir(conn, fullname) != 0)
                                                                break;
                                                }
-                                               if(vfs_rmdir(conn,fullname) != 0)
+                                               if(VFS_RMDIR(conn,fullname) != 0)
                                                        break;
-                                       } else if(vfs_unlink(conn,fullname) != 0)
+                                       } else if(VFS_UNLINK(conn,fullname) != 0)
                                                break;
                                }
                                CloseDir(dirptr);
                                /* Retry the rmdir */
-                               ok = (vfs_rmdir(conn,directory) == 0);
+                               ok = (VFS_RMDIR(conn,directory) == 0);
                        } else {
                                CloseDir(dirptr);
                        }
@@ -3284,7 +3284,7 @@ directory = %s, newname = %s, newname_last_component = %s, is_8_3 = %d\n",
                        return NT_STATUS_OBJECT_NAME_COLLISION;
                }
 
-               if(conn->vfs_ops.rename(conn,directory, newname) == 0) {
+               if(VFS_RENAME(conn,directory, newname) == 0) {
                        DEBUG(3,("rename_internals: succeeded doing rename on %s -> %s\n",
                                directory,newname));
                        return NT_STATUS_OK;    
@@ -3351,7 +3351,7 @@ directory = %s, newname = %s, newname_last_component = %s, is_8_3 = %d\n",
                                        continue;
                                }
                                
-                               if (!conn->vfs_ops.rename(conn,fname,destname))
+                               if (!VFS_RENAME(conn,fname,destname))
                                        count++;
                                DEBUG(3,("rename_internals: doing rename on %s -> %s\n",fname,destname));
                        }
@@ -3445,7 +3445,7 @@ static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun,
        if (!target_is_directory && count)
                ofun = FILE_EXISTS_OPEN;
 
-       if (vfs_stat(conn,dest,&sbuf2) == -1)
+       if (VFS_STAT(conn,dest,&sbuf2) == -1)
                ZERO_STRUCTP(&sbuf2);
 
        fsp2 = open_file_shared(conn,dest,&sbuf2,SET_DENY_MODE(DENY_NONE)|SET_OPEN_MODE(DOS_OPEN_WRONLY),
@@ -3457,7 +3457,7 @@ static BOOL copy_file(char *src,char *dest1,connection_struct *conn, int ofun,
        }
 
        if ((ofun&3) == 1) {
-               if(conn->vfs_ops.lseek(fsp2,fsp2->fd,0,SEEK_END) == -1) {
+               if(VFS_LSEEK(fsp2,fsp2->fd,0,SEEK_END) == -1) {
                        DEBUG(0,("copy_file: error - vfs lseek returned error %s\n", strerror(errno) ));
                        /*
                         * Stop the copy from occurring.
index cfb5e0e4143645307e0350a14a1b97f81524fba1..0e4c87c7fb2523aebc56f24d6f3ba766d98d8955 100644 (file)
@@ -704,14 +704,12 @@ static connection_struct *make_connection_snum(int snum, user_struct *vuser,
        
        /* Invoke VFS make connection hook */
 
-       if (conn->vfs_ops.connect) {
-               if (conn->vfs_ops.connect(conn, lp_servicename(snum), user) < 0) {
-                       DEBUG(0,("make_connection: VFS make connection failed!\n"));
-                       change_to_root_user();
-                       conn_free(conn);
-                       *status = NT_STATUS_UNSUCCESSFUL;
-                       return NULL;
-               }
+       if (VFS_CONNECT(conn, lp_servicename(snum), user) < 0) {
+               DEBUG(0,("make_connection: VFS make connection failed!\n"));
+               change_to_root_user();
+               conn_free(conn);
+               *status = NT_STATUS_UNSUCCESSFUL;
+               return NULL;
        }
 
        /* we've finished with the user stuff - go back to root */
@@ -872,13 +870,8 @@ void close_cnum(connection_struct *conn, uint16 vuid)
                                 get_remote_machine_name(),conn->client_address,
                                 lp_servicename(SNUM(conn))));
 
-       if (conn->vfs_ops.disconnect != NULL) {
-
-           /* Call VFS disconnect hook */
-           
-           conn->vfs_ops.disconnect(conn);
-           
-       }
+       /* Call VFS disconnect hook */    
+       VFS_DISCONNECT(conn);
 
        yield_connection(conn, lp_servicename(SNUM(conn)));
 
index 44bae48990c2c4aa06d02bccd38e75673641c3b7..5c77474fec157f40b1f1089f9e5c3a4e80b29962 100644 (file)
@@ -242,7 +242,7 @@ BOOL stat_cache_lookup(connection_struct *conn, pstring name, pstring dirpath,
     } else {
       scp = (stat_cache_entry *)(hash_elem->value);
       DO_PROFILE_INC(statcache_hits);
-      if(vfs_stat(conn,scp->translated_path, pst) != 0) {
+      if(VFS_STAT(conn,scp->translated_path, pst) != 0) {
         /* Discard this entry - it doesn't exist in the filesystem.  */
         hash_remove(&stat_cache, hash_elem);
         return False;
index de598d671398825290fb876d6fdc258b22864418..c9eef637d9598330bdee2c698f52e87d2d2b0459 100644 (file)
@@ -549,12 +549,12 @@ static BOOL get_lanman2_dir_entry(connection_struct *conn,
                        pstrcat(pathreal,dname);
 
                        if (INFO_LEVEL_IS_UNIX(info_level)) {
-                               if (vfs_lstat(conn,pathreal,&sbuf) != 0) {
+                               if (VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
                                        DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
                                                pathreal,strerror(errno)));
                                        continue;
                                }
-                       } else if (vfs_stat(conn,pathreal,&sbuf) != 0) {
+                       } else if (VFS_STAT(conn,pathreal,&sbuf) != 0) {
 
                                /* Needed to show the msdfs symlinks as 
                                 * directories */
@@ -1321,7 +1321,7 @@ static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf
 
        DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
 
-       if(vfs_stat(conn,".",&st)!=0) {
+       if(VFS_STAT(conn,".",&st)!=0) {
                DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
                return ERROR_DOS(ERRSRV,ERRinvdevice);
        }
@@ -1338,7 +1338,7 @@ static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf
                {
                        SMB_BIG_UINT dfree,dsize,bsize;
                        data_len = 18;
-                       conn->vfs_ops.disk_free(conn,".",False,&bsize,&dfree,&dsize);   
+                       VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);     
                        SIVAL(pdata,l1_idFileSystem,st.st_dev);
                        SIVAL(pdata,l1_cSectorUnit,bsize/512);
                        SIVAL(pdata,l1_cUnit,dsize);
@@ -1406,7 +1406,7 @@ static int call_trans2qfsinfo(connection_struct *conn, char *inbuf, char *outbuf
                {
                        SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
                        data_len = 24;
-                       conn->vfs_ops.disk_free(conn,".",False,&bsize,&dfree,&dsize);
+                       VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
                        block_size = lp_block_size(snum);
                        if (bsize < block_size) {
                                SMB_BIG_UINT factor = block_size/bsize;
@@ -1436,7 +1436,7 @@ cBytesSector=%u, cUnitTotal=%u, cUnitAvail=%d\n", (unsigned int)bsize, (unsigned
                {
                        SMB_BIG_UINT dfree,dsize,bsize,block_size,sectors_per_unit,bytes_per_sector;
                        data_len = 32;
-                       conn->vfs_ops.disk_free(conn,".",False,&bsize,&dfree,&dsize);
+                       VFS_DISK_FREE(conn,".",False,&bsize,&dfree,&dsize);
                        block_size = lp_block_size(snum);
                        if (bsize < block_size) {
                                SMB_BIG_UINT factor = block_size/bsize;
@@ -1605,13 +1605,13 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
                  
                        if (INFO_LEVEL_IS_UNIX(info_level)) {
                                /* Always do lstat for UNIX calls. */
-                               if (vfs_lstat(conn,fname,&sbuf)) {
-                                       DEBUG(3,("call_trans2qfilepathinfo: vfs_lstat of %s failed (%s)\n",fname,strerror(errno)));
+                               if (VFS_LSTAT(conn,fname,&sbuf)) {
+                                       DEBUG(3,("call_trans2qfilepathinfo: VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
                                        set_bad_path_error(errno, bad_path);
                                        return(UNIXERROR(ERRDOS,ERRbadpath));
                                }
-                       } else if (!VALID_STAT(sbuf) && vfs_stat(conn,fname,&sbuf)) {
-                               DEBUG(3,("call_trans2qfilepathinfo: vfs_stat of %s failed (%s)\n",fname,strerror(errno)));
+                       } else if (!VALID_STAT(sbuf) && VFS_STAT(conn,fname,&sbuf)) {
+                               DEBUG(3,("call_trans2qfilepathinfo: VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
                                set_bad_path_error(errno, bad_path);
                                return(UNIXERROR(ERRDOS,ERRbadpath));
                        }
@@ -1624,11 +1624,11 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
                        CHECK_FSP(fsp,conn);
 
                        pstrcpy(fname, fsp->fsp_name);
-                       if (vfs_fstat(fsp,fsp->fd,&sbuf) != 0) {
+                       if (VFS_FSTAT(fsp,fsp->fd,&sbuf) != 0) {
                                DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
                                return(UNIXERROR(ERRDOS,ERRbadfid));
                        }
-                       if((pos = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,0,SEEK_CUR)) == -1)
+                       if((pos = VFS_LSEEK(fsp,fsp->fd,0,SEEK_CUR)) == -1)
                                return(UNIXERROR(ERRDOS,ERRnoaccess));
 
                        delete_pending = fsp->delete_on_close;
@@ -1655,13 +1655,13 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
 
                if (INFO_LEVEL_IS_UNIX(info_level)) {
                        /* Always do lstat for UNIX calls. */
-                       if (vfs_lstat(conn,fname,&sbuf)) {
-                               DEBUG(3,("call_trans2qfilepathinfo: vfs_lstat of %s failed (%s)\n",fname,strerror(errno)));
+                       if (VFS_LSTAT(conn,fname,&sbuf)) {
+                               DEBUG(3,("call_trans2qfilepathinfo: VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
                                set_bad_path_error(errno, bad_path);
                                return(UNIXERROR(ERRDOS,ERRbadpath));
                        }
-               } else if (!VALID_STAT(sbuf) && vfs_stat(conn,fname,&sbuf)) {
-                       DEBUG(3,("call_trans2qfilepathinfo: vfs_stat of %s failed (%s)\n",fname,strerror(errno)));
+               } else if (!VALID_STAT(sbuf) && VFS_STAT(conn,fname,&sbuf)) {
+                       DEBUG(3,("call_trans2qfilepathinfo: VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
                        set_bad_path_error(errno, bad_path);
                        return(UNIXERROR(ERRDOS,ERRbadpath));
                }
@@ -2054,7 +2054,7 @@ static int call_trans2qfilepathinfo(connection_struct *conn,
 #else
                                return(UNIXERROR(ERRDOS,ERRbadlink));
 #endif
-                               len = conn->vfs_ops.readlink(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
+                               len = VFS_READLINK(conn,fullpathname, buffer, sizeof(pstring)-1);     /* read link */
                                if (len == -1)
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                                buffer[len] = 0;
@@ -2178,7 +2178,7 @@ static int ensure_link_is_safe(connection_struct *conn, const char *link_dest_in
                pstrcpy(link_dest, "./");
        }
                
-       if (conn->vfs_ops.realpath(conn,link_dest,resolved_name) == NULL)
+       if (VFS_REALPATH(conn,link_dest,resolved_name) == NULL)
                return -1;
 
        pstrcpy(link_dest, resolved_name);
@@ -2269,7 +2269,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
                        pstrcpy(fname, fsp->fsp_name);
                        fd = fsp->fd;
 
-                       if (vfs_fstat(fsp,fd,&sbuf) != 0) {
+                       if (VFS_FSTAT(fsp,fd,&sbuf) != 0) {
                                DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
                                return(UNIXERROR(ERRDOS,ERRbadfid));
                        }
@@ -2461,7 +2461,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
                                        if (new_fsp == NULL)
                                                return(UNIXERROR(ERRDOS,ERRbadpath));
                                        ret = vfs_allocate_file_space(new_fsp, allocation_size);
-                                       if (vfs_fstat(new_fsp,new_fsp->fd,&new_sbuf) != 0) {
+                                       if (VFS_FSTAT(new_fsp,new_fsp->fd,&new_sbuf) != 0) {
                                                DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
                                                                        new_fsp->fnum, strerror(errno)));
                                                ret = -1;
@@ -2469,7 +2469,7 @@ static int call_trans2setfilepathinfo(connection_struct *conn,
                                        close_file(new_fsp,True);
                                } else {
                                        ret = vfs_allocate_file_space(fsp, allocation_size);
-                                       if (vfs_fstat(fsp,fd,&new_sbuf) != 0) {
+                                       if (VFS_FSTAT(fsp,fd,&new_sbuf) != 0) {
                                                DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",
                                                                        fsp->fnum, strerror(errno)));
                                                ret = -1;
@@ -2609,7 +2609,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
 0%o for file %s\n", (double)dev, unixmode, fname ));
 
                                /* Ok - do the mknod. */
-                               if (conn->vfs_ops.mknod(conn,dos_to_unix_static(fname), unixmode, dev) != 0)
+                               if (VFS_MKNOD(conn,dos_to_unix_static(fname), unixmode, dev) != 0)
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
 
                                inherit_access_acl(conn, fname, unixmode);
@@ -2628,7 +2628,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                        if (raw_unixmode != SMB_MODE_NO_CHANGE) {
                                DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC setting mode 0%o for file %s\n",
                                        (unsigned int)unixmode, fname ));
-                               if (vfs_chmod(conn,fname,unixmode) != 0)
+                               if (VFS_CHMOD(conn,fname,unixmode) != 0)
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                        }
 
@@ -2639,7 +2639,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                        if ((set_owner != (uid_t)SMB_UID_NO_CHANGE) && (sbuf.st_uid != set_owner)) {
                                DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing owner %u for file %s\n",
                                        (unsigned int)set_owner, fname ));
-                               if (vfs_chown(conn,fname,set_owner, (gid_t)-1) != 0)
+                               if (VFS_CHOWN(conn,fname,set_owner, (gid_t)-1) != 0)
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                        }
 
@@ -2650,7 +2650,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                        if ((set_grp != (uid_t)SMB_GID_NO_CHANGE) && (sbuf.st_gid != set_grp)) {
                                DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_BASIC changing group %u for file %s\n",
                                        (unsigned int)set_owner, fname ));
-                               if (vfs_chown(conn,fname,(uid_t)-1, set_grp) != 0)
+                               if (VFS_CHOWN(conn,fname,(uid_t)-1, set_grp) != 0)
                                        return(UNIXERROR(ERRDOS,ERRnoaccess));
                        }
                        break;
@@ -2677,7 +2677,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                        DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing symlink %s -> %s\n",
                                fname, link_dest ));
 
-                       if (conn->vfs_ops.symlink(conn,link_dest,fname) != 0)
+                       if (VFS_SYMLINK(conn,link_dest,fname) != 0)
                                return(UNIXERROR(ERRDOS,ERRnoaccess));
                        SSVAL(params,0,0);
                        send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
@@ -2702,7 +2702,7 @@ size = %.0f, uid = %u, gid = %u, raw perms = 0%o\n",
                        DEBUG(10,("call_trans2setfilepathinfo: SMB_SET_FILE_UNIX_LINK doing hard link %s -> %s\n",
                                fname, link_dest ));
 
-                       if (conn->vfs_ops.link(conn,link_dest,fname) != 0)
+                       if (VFS_LINK(conn,link_dest,fname) != 0)
                                return(UNIXERROR(ERRDOS,ERRnoaccess));
                        SSVAL(params,0,0);
                        send_trans2_replies(outbuf, bufsize, params, 2, *ppdata, 0);
@@ -2854,7 +2854,7 @@ static int call_trans2mkdir(connection_struct *conn,
 
        unix_convert(directory,conn,0,&bad_path,&sbuf);
        if (check_name(directory,conn))
-               ret = vfs_mkdir(conn,directory,unix_mode(conn,aDIR,directory));
+               ret = vfs_MkDir(conn,directory,unix_mode(conn,aDIR,directory));
   
        if(ret < 0) {
                DEBUG(5,("call_trans2mkdir error (%s)\n", strerror(errno)));
index 491fa70e687ea761129112f3940c8208a9793781..4422666006df9c3827ea8b307c411d4193c09ea1 100644 (file)
    is sure to try and execute them.  These stubs are used to prevent
    this possibility. */
 
-int vfswrap_dummy_connect(connection_struct *conn, const char *service, const char *user)
+int vfswrap_dummy_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user)
 {
     return 0;    /* Return >= 0 for success */
 }
 
-void vfswrap_dummy_disconnect(connection_struct *conn)
+void vfswrap_dummy_disconnect(vfs_handle_struct *handle, connection_struct *conn)
 {
 }
 
 /* Disk operations */
 
-SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize, 
+SMB_BIG_UINT vfswrap_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;
@@ -52,7 +52,7 @@ SMB_BIG_UINT vfswrap_disk_free(connection_struct *conn, const char *path, BOOL s
     
 /* Directory operations */
 
-DIR *vfswrap_opendir(connection_struct *conn, const char *fname)
+DIR *vfswrap_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname)
 {
     DIR *result;
 
@@ -62,7 +62,7 @@ DIR *vfswrap_opendir(connection_struct *conn, const char *fname)
     return result;
 }
 
-struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp)
+struct dirent *vfswrap_readdir(vfs_handle_struct *handle, connection_struct *conn, DIR *dirp)
 {
     struct dirent *result;
 
@@ -72,7 +72,7 @@ struct dirent *vfswrap_readdir(connection_struct *conn, DIR *dirp)
     return result;
 }
 
-int vfswrap_mkdir(connection_struct *conn, const char *path, mode_t mode)
+int vfswrap_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
        int result;
        BOOL has_dacl = False;
@@ -93,8 +93,8 @@ int vfswrap_mkdir(connection_struct *conn, const char *path, mode_t mode)
                 * mess up any inherited ACL bits that were set. JRA.
                 */
                int saved_errno = errno; /* We may get ENOSYS */
-               if (conn->vfs_ops.chmod_acl != NULL) {
-                       if ((conn->vfs_ops.chmod_acl(conn, path, mode) == -1) && (errno == ENOSYS))
+               if (conn->vfs.ops.chmod_acl != NULL) {
+                       if ((VFS_CHMOD_ACL(conn, path, mode) == -1) && (errno == ENOSYS))
                                errno = saved_errno;
                }
        }
@@ -103,7 +103,7 @@ int vfswrap_mkdir(connection_struct *conn, const char *path, mode_t mode)
     return result;
 }
 
-int vfswrap_rmdir(connection_struct *conn, const char *path)
+int vfswrap_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
     int result;
 
@@ -113,7 +113,7 @@ int vfswrap_rmdir(connection_struct *conn, const char *path)
     return result;
 }
 
-int vfswrap_closedir(connection_struct *conn, DIR *dirp)
+int vfswrap_closedir(vfs_handle_struct *handle, connection_struct *conn, DIR *dirp)
 {
     int result;
 
@@ -125,7 +125,7 @@ int vfswrap_closedir(connection_struct *conn, DIR *dirp)
 
 /* File operations */
     
-int vfswrap_open(connection_struct *conn, const char *fname, int flags, mode_t mode)
+int vfswrap_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode)
 {
     int result;
 
@@ -135,7 +135,7 @@ int vfswrap_open(connection_struct *conn, const char *fname, int flags, mode_t m
     return result;
 }
 
-int vfswrap_close(files_struct *fsp, int fd)
+int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 {
     int result;
 
@@ -146,7 +146,7 @@ int vfswrap_close(files_struct *fsp, int fd)
     return result;
 }
 
-ssize_t vfswrap_read(files_struct *fsp, int fd, void *data, size_t n)
+ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
 {
     ssize_t result;
 
@@ -156,7 +156,7 @@ ssize_t vfswrap_read(files_struct *fsp, int fd, void *data, size_t n)
     return result;
 }
 
-ssize_t vfswrap_write(files_struct *fsp, int fd, const void *data, size_t n)
+ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
 {
     ssize_t result;
 
@@ -166,7 +166,7 @@ ssize_t vfswrap_write(files_struct *fsp, int fd, const void *data, size_t n)
     return result;
 }
 
-SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
+SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 {
        SMB_OFF_T result = 0;
 
@@ -192,7 +192,7 @@ SMB_OFF_T vfswrap_lseek(files_struct *fsp, int filedes, SMB_OFF_T offset, int wh
        return result;
 }
 
-ssize_t vfswrap_sendfile(int tofd, struct files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
+ssize_t vfswrap_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;
@@ -203,7 +203,7 @@ ssize_t vfswrap_sendfile(int tofd, struct files_struct *fsp, int fromfd, const D
        return result;
 }
 
-int vfswrap_rename(connection_struct *conn, const char *old, const char *new)
+int vfswrap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *old, const char *new)
 {
     int result;
 
@@ -213,7 +213,7 @@ int vfswrap_rename(connection_struct *conn, const char *old, const char *new)
     return result;
 }
 
-int vfswrap_fsync(files_struct *fsp, int fd)
+int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
 {
 #ifdef HAVE_FSYNC
     int result;
@@ -228,7 +228,7 @@ int vfswrap_fsync(files_struct *fsp, int fd)
 #endif
 }
 
-int vfswrap_stat(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
+int vfswrap_stat(vfs_handle_struct *handle, connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
 {
     int result;
 
@@ -238,7 +238,7 @@ int vfswrap_stat(connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sb
     return result;
 }
 
-int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
+int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 {
     int result;
 
@@ -248,7 +248,7 @@ int vfswrap_fstat(files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
     return result;
 }
 
-int vfswrap_lstat(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
+int vfswrap_lstat(vfs_handle_struct *handle, connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
 {
     int result;
 
@@ -258,7 +258,7 @@ int vfswrap_lstat(connection_struct *conn, const char *path, SMB_STRUCT_STAT *sb
     return result;
 }
 
-int vfswrap_unlink(connection_struct *conn, const char *path)
+int vfswrap_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
     int result;
 
@@ -268,7 +268,7 @@ int vfswrap_unlink(connection_struct *conn, const char *path)
     return result;
 }
 
-int vfswrap_chmod(connection_struct *conn, const char *path, mode_t mode)
+int vfswrap_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
 {
     int result;
 
@@ -281,9 +281,9 @@ int vfswrap_chmod(connection_struct *conn, const char *path, mode_t mode)
         */
 
        
-       if (conn->vfs_ops.chmod_acl != NULL) {
+       if (conn->vfs.ops.chmod_acl != NULL) {
                int saved_errno = errno; /* We might get ENOSYS */
-               if ((result = conn->vfs_ops.chmod_acl(conn, path, mode)) == 0) {
+               if ((result = VFS_CHMOD_ACL(conn, path, mode)) == 0) {
                        END_PROFILE(syscall_chmod);
                        return result;
                }
@@ -296,10 +296,10 @@ int vfswrap_chmod(connection_struct *conn, const char *path, mode_t mode)
     return result;
 }
 
-int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
+int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
        int result;
-       struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
+       struct vfs_ops *vfs_ops = &fsp->conn->vfs;
        
        START_PROFILE(syscall_fchmod);
 
@@ -309,9 +309,9 @@ int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
         * group owner bits directly. JRA.
         */
        
-       if (vfs_ops->fchmod_acl != NULL) {
+       if (vfs_ops->ops.fchmod_acl != NULL) {
                int saved_errno = errno; /* We might get ENOSYS */
-               if ((result = vfs_ops->fchmod_acl(fsp, fd, mode)) == 0) {
+               if ((result = VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
                        END_PROFILE(syscall_chmod);
                        return result;
                }
@@ -330,7 +330,7 @@ int vfswrap_fchmod(files_struct *fsp, int fd, mode_t mode)
        return result;
 }
 
-int vfswrap_chown(connection_struct *conn, const char *path, uid_t uid, gid_t gid)
+int vfswrap_chown(vfs_handle_struct *handle, connection_struct *conn, const char *path, uid_t uid, gid_t gid)
 {
     int result;
 
@@ -340,7 +340,7 @@ int vfswrap_chown(connection_struct *conn, const char *path, uid_t uid, gid_t gi
     return result;
 }
 
-int vfswrap_fchown(files_struct *fsp, int fd, uid_t uid, gid_t gid)
+int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
 {
 #ifdef HAVE_FCHOWN
     int result;
@@ -356,7 +356,7 @@ int vfswrap_fchown(files_struct *fsp, int fd, uid_t uid, gid_t gid)
 #endif
 }
 
-int vfswrap_chdir(connection_struct *conn, const char *path)
+int vfswrap_chdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
     int result;
 
@@ -366,7 +366,7 @@ int vfswrap_chdir(connection_struct *conn, const char *path)
     return result;
 }
 
-char *vfswrap_getwd(connection_struct *conn, char *path)
+char *vfswrap_getwd(vfs_handle_struct *handle, connection_struct *conn, char *path)
 {
     char *result;
 
@@ -376,7 +376,7 @@ char *vfswrap_getwd(connection_struct *conn, char *path)
     return result;
 }
 
-int vfswrap_utime(connection_struct *conn, const char *path, struct utimbuf *times)
+int vfswrap_utime(vfs_handle_struct *handle, connection_struct *conn, const char *path, struct utimbuf *times)
 {
     int result;
 
@@ -391,18 +391,17 @@ int vfswrap_utime(connection_struct *conn, const char *path, struct utimbuf *tim
  allocate is set.
 **********************************************************************/
 
-static int strict_allocate_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
+static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 {
-       struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
        SMB_STRUCT_STAT st;
-       SMB_OFF_T currpos = vfs_ops->lseek(fsp, fd, 0, SEEK_CUR);
+       SMB_OFF_T currpos = VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
        unsigned char zero_space[4096];
        SMB_OFF_T space_to_write;
 
        if (currpos == -1)
                return -1;
 
-       if (vfs_ops->fstat(fsp, fd, &st) == -1)
+       if (VFS_FSTAT(fsp, fd, &st) == -1)
                return -1;
 
        space_to_write = len - st.st_size;
@@ -420,7 +419,7 @@ static int strict_allocate_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
                return sys_ftruncate(fd, len);
 
        /* Write out the real space on disk. */
-       if (vfs_ops->lseek(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
+       if (VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
                return -1;
 
        space_to_write = len - st.st_size;
@@ -430,7 +429,7 @@ static int strict_allocate_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
                SMB_OFF_T retlen;
                SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 
-               retlen = vfs_ops->write(fsp,fsp->fd,(char *)zero_space,current_len_to_write);
+               retlen = VFS_WRITE(fsp,fsp->fd,(char *)zero_space,current_len_to_write);
                if (retlen <= 0)
                        return -1;
 
@@ -438,16 +437,15 @@ static int strict_allocate_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
        }
 
        /* Seek to where we were */
-       if (vfs_ops->lseek(fsp, fd, currpos, SEEK_SET) != currpos)
+       if (VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
                return -1;
 
        return 0;
 }
 
-int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
+int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 {
        int result = -1;
-       struct vfs_ops *vfs_ops = &fsp->conn->vfs_ops;
        SMB_STRUCT_STAT st;
        char c = 0;
        SMB_OFF_T currpos;
@@ -455,7 +453,7 @@ int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
        START_PROFILE(syscall_ftruncate);
 
        if (lp_strict_allocate(SNUM(fsp->conn))) {
-               result = strict_allocate_ftruncate(fsp, fd, len);
+               result = strict_allocate_ftruncate(handle, fsp, fd, len);
                END_PROFILE(syscall_ftruncate);
                return result;
        }
@@ -473,7 +471,7 @@ int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
        /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
           extend a file with ftruncate. Provide alternate implementation
           for this */
-       currpos = vfs_ops->lseek(fsp, fd, 0, SEEK_CUR);
+       currpos = VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
        if (currpos == -1) {
                goto done;
        }
@@ -482,7 +480,7 @@ int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
           size in which case the ftruncate above should have
           succeeded or shorter, in which case seek to len - 1 and
           write 1 byte of zero */
-       if (vfs_ops->fstat(fsp, fd, &st) == -1) {
+       if (VFS_FSTAT(fsp, fd, &st) == -1) {
                goto done;
        }
 
@@ -503,14 +501,14 @@ int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
                goto done;
        }
 
-       if (vfs_ops->lseek(fsp, fd, len-1, SEEK_SET) != len -1)
+       if (VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
                goto done;
 
-       if (vfs_ops->write(fsp, fd, &c, 1)!=1)
+       if (VFS_WRITE(fsp, fd, &c, 1)!=1)
                goto done;
 
        /* Seek to where we were */
-       if (vfs_ops->lseek(fsp, fd, currpos, SEEK_SET) != currpos)
+       if (VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
                goto done;
        result = 0;
 
@@ -520,7 +518,7 @@ int vfswrap_ftruncate(files_struct *fsp, int fd, SMB_OFF_T len)
        return result;
 }
 
-BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
+BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 {
     BOOL result;
 
@@ -531,7 +529,7 @@ BOOL vfswrap_lock(files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T
     return result;
 }
 
-int vfswrap_symlink(connection_struct *conn, const char *oldpath, const char *newpath)
+int vfswrap_symlink(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
 {
     int result;
 
@@ -541,7 +539,7 @@ int vfswrap_symlink(connection_struct *conn, const char *oldpath, const char *ne
     return result;
 }
 
-int vfswrap_readlink(connection_struct *conn, const char *path, char *buf, size_t bufsiz)
+int vfswrap_readlink(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *buf, size_t bufsiz)
 {
     int result;
 
@@ -551,7 +549,7 @@ int vfswrap_readlink(connection_struct *conn, const char *path, char *buf, size_
     return result;
 }
 
-int vfswrap_link(connection_struct *conn, const char *oldpath, const char *newpath)
+int vfswrap_link(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
 {
        int result;
 
@@ -561,7 +559,7 @@ int vfswrap_link(connection_struct *conn, const char *oldpath, const char *newpa
        return result;
 }
 
-int vfswrap_mknod(connection_struct *conn, const char *pathname, mode_t mode, SMB_DEV_T dev)
+int vfswrap_mknod(vfs_handle_struct *handle, connection_struct *conn, const char *pathname, mode_t mode, SMB_DEV_T dev)
 {
        int result;
 
@@ -571,7 +569,7 @@ int vfswrap_mknod(connection_struct *conn, const char *pathname, mode_t mode, SM
        return result;
 }
 
-char *vfswrap_realpath(connection_struct *conn, const char *path, char *resolved_path)
+char *vfswrap_realpath(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *resolved_path)
 {
        char *result;
 
@@ -581,7 +579,7 @@ char *vfswrap_realpath(connection_struct *conn, const char *path, char *resolved
        return result;
 }
 
-size_t vfswrap_fget_nt_acl(files_struct *fsp, int fd, SEC_DESC **ppdesc)
+size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, SEC_DESC **ppdesc)
 {
        size_t result;
 
@@ -591,7 +589,7 @@ size_t vfswrap_fget_nt_acl(files_struct *fsp, int fd, SEC_DESC **ppdesc)
        return result;
 }
 
-size_t vfswrap_get_nt_acl(files_struct *fsp, const char *name, SEC_DESC **ppdesc)
+size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, SEC_DESC **ppdesc)
 {
        size_t result;
 
@@ -601,7 +599,7 @@ size_t vfswrap_get_nt_acl(files_struct *fsp, const char *name, SEC_DESC **ppdesc
        return result;
 }
 
-BOOL vfswrap_fset_nt_acl(files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
+BOOL vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
 {
        BOOL result;
 
@@ -611,7 +609,7 @@ BOOL vfswrap_fset_nt_acl(files_struct *fsp, int fd, uint32 security_info_sent, S
        return result;
 }
 
-BOOL vfswrap_set_nt_acl(files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
+BOOL vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
 {
        BOOL result;
 
@@ -621,7 +619,7 @@ BOOL vfswrap_set_nt_acl(files_struct *fsp, const char *name, uint32 security_inf
        return result;
 }
 
-int vfswrap_chmod_acl(connection_struct *conn, const char *name, mode_t mode)
+int vfswrap_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode)
 {
        int result;
 
@@ -631,7 +629,7 @@ int vfswrap_chmod_acl(connection_struct *conn, const char *name, mode_t mode)
        return result;
 }
 
-int vfswrap_fchmod_acl(files_struct *fsp, int fd, mode_t mode)
+int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 {
        int result;
 
@@ -641,112 +639,124 @@ int vfswrap_fchmod_acl(files_struct *fsp, int fd, mode_t mode)
        return result;
 }
 
-int vfswrap_sys_acl_get_entry(struct connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
+int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 {
        return sys_acl_get_entry(theacl, entry_id, entry_p);
 }
 
-int vfswrap_sys_acl_get_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
+int vfswrap_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)
 {
        return sys_acl_get_tag_type(entry_d, tag_type_p);
 }
 
-int vfswrap_sys_acl_get_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
+int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 {
        return sys_acl_get_permset(entry_d, permset_p);
 }
 
-void * vfswrap_sys_acl_get_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
+void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
 {
        return sys_acl_get_qualifier(entry_d);
 }
 
-SMB_ACL_T vfswrap_sys_acl_get_file(struct connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
+SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
 {
        return sys_acl_get_file(path_p, type);
 }
 
-SMB_ACL_T vfswrap_sys_acl_get_fd(struct files_struct *fsp, int fd)
+SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
 {
        return sys_acl_get_fd(fd);
 }
 
-int vfswrap_sys_acl_clear_perms(struct connection_struct *conn, SMB_ACL_PERMSET_T permset)
+int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset)
 {
        return sys_acl_clear_perms(permset);
 }
 
-int vfswrap_sys_acl_add_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
+int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 {
        return sys_acl_add_perm(permset, perm);
 }
 
-char * vfswrap_sys_acl_to_text(struct connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
+char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
 {
        return sys_acl_to_text(theacl, plen);
 }
 
-SMB_ACL_T vfswrap_sys_acl_init(struct connection_struct *conn, int count)
+SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, connection_struct *conn, int count)
 {
        return sys_acl_init(count);
 }
 
-int vfswrap_sys_acl_create_entry(struct connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
+int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 {
        return sys_acl_create_entry(pacl, pentry);
 }
 
-int vfswrap_sys_acl_set_tag_type(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
+int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 {
        return sys_acl_set_tag_type(entry, tagtype);
 }
 
-int vfswrap_sys_acl_set_qualifier(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
+int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
 {
        return sys_acl_set_qualifier(entry, qual);
 }
 
-int vfswrap_sys_acl_set_permset(struct connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
+int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 {
        return sys_acl_set_permset(entry, permset);
 }
 
-int vfswrap_sys_acl_valid(struct connection_struct *conn, SMB_ACL_T theacl )
+int vfswrap_sys_acl_valid(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl )
 {
        return sys_acl_valid(theacl );
 }
 
-int vfswrap_sys_acl_set_file(struct connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
+int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 {
        return sys_acl_set_file(name, acltype, theacl);
 }
 
-int vfswrap_sys_acl_set_fd(struct files_struct *fsp, int fd, SMB_ACL_T theacl)
+int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
 {
        return sys_acl_set_fd(fd, theacl);
 }
 
-int vfswrap_sys_acl_delete_def_file(struct connection_struct *conn, const char *path)
+int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, connection_struct *conn, const char *path)
 {
        return sys_acl_delete_def_file(path);
 }
 
-int vfswrap_sys_acl_get_perm(struct connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
+int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 {
        return sys_acl_get_perm(permset, perm);
 }
 
-int vfswrap_sys_acl_free_text(struct connection_struct *conn, char *text)
+int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, connection_struct *conn, char *text)
 {
        return sys_acl_free_text(text);
 }
 
-int vfswrap_sys_acl_free_acl(struct connection_struct *conn, SMB_ACL_T posix_acl)
+int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T posix_acl)
 {
        return sys_acl_free_acl(posix_acl);
 }
 
-int vfswrap_sys_acl_free_qualifier(struct connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
+int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
 {
        return sys_acl_free_qualifier(qualifier, tagtype);
 }
+
+int vfswrap_get_quota(vfs_handle_struct *handle, connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
+{
+       errno = ENOSYS;
+       return -1;      
+}
+
+int vfswrap_set_quota(vfs_handle_struct *handle, connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
+{
+       errno = ENOSYS;
+       return -1;
+}
index 5fcf9a575e400b952ad1535549f028af072e8310..7bae2ccc80093ee5028cf73339acfc16238c37b3 100644 (file)
@@ -28,9 +28,9 @@
 #define DBGC_CLASS DBGC_VFS
 
 struct vfs_init_function_entry {
-   char *name;
-   vfs_op_tuple *ops, *(*init)(const struct vfs_ops *, struct smb_vfs_handle_struct *);
-   struct vfs_init_function_entry *prev, *next;
+       char *name;
+       vfs_op_tuple *vfs_op_tuples;
+       struct vfs_init_function_entry *prev, *next;
 };
 
 static struct vfs_init_function_entry *backends = NULL;
@@ -42,96 +42,94 @@ struct vfs_syminfo {
        void *fptr;
 };
 
-/*
-  Opaque (final) vfs operations. This is a combination of first-met opaque vfs operations
-  across all currently processed modules.  */
-
-static vfs_op_tuple vfs_opaque_ops[SMB_VFS_OP_LAST];
-
 /* Default vfs hooks.  WARNING: The order of these initialisers is
    very important.  They must be in the same order as defined in
    vfs.h.  Change at your own peril. */
 
-static struct vfs_ops default_vfs_ops = {
-
-       /* Disk operations */
-
-       vfswrap_dummy_connect,
-       vfswrap_dummy_disconnect,
-       vfswrap_disk_free,
-
-       /* Directory operations */
-
-       vfswrap_opendir,
-       vfswrap_readdir,
-       vfswrap_mkdir,
-       vfswrap_rmdir,
-       vfswrap_closedir,
-
-       /* File operations */
-
-       vfswrap_open,
-       vfswrap_close,
-       vfswrap_read,
-       vfswrap_write,
-       vfswrap_lseek,
-       vfswrap_sendfile,
-       vfswrap_rename,
-       vfswrap_fsync,
-       vfswrap_stat,
-       vfswrap_fstat,
-       vfswrap_lstat,
-       vfswrap_unlink,
-       vfswrap_chmod,
-       vfswrap_fchmod,
-       vfswrap_chown,
-       vfswrap_fchown,
-       vfswrap_chdir,
-       vfswrap_getwd,
-       vfswrap_utime,
-       vfswrap_ftruncate,
-       vfswrap_lock,
-       vfswrap_symlink,
-       vfswrap_readlink,
-       vfswrap_link,
-       vfswrap_mknod,
-       vfswrap_realpath,
-
-       vfswrap_fget_nt_acl,
-       vfswrap_get_nt_acl,
-       vfswrap_fset_nt_acl,
-       vfswrap_set_nt_acl,
-
-       /* POSIX ACL operations. */
+static struct vfs_ops default_vfs = {
+
+       ops: {
+               /* Disk operations */
+       
+               vfswrap_dummy_connect,
+               vfswrap_dummy_disconnect,
+               vfswrap_disk_free,
+               vfswrap_get_quota,
+               vfswrap_set_quota,
+       
+               /* Directory operations */
+       
+               vfswrap_opendir,
+               vfswrap_readdir,
+               vfswrap_mkdir,
+               vfswrap_rmdir,
+               vfswrap_closedir,
+       
+               /* File operations */
+       
+               vfswrap_open,
+               vfswrap_close,
+               vfswrap_read,
+               vfswrap_write,
+               vfswrap_lseek,
+               vfswrap_sendfile,
+               vfswrap_rename,
+               vfswrap_fsync,
+               vfswrap_stat,
+               vfswrap_fstat,
+               vfswrap_lstat,
+               vfswrap_unlink,
+               vfswrap_chmod,
+               vfswrap_fchmod,
+               vfswrap_chown,
+               vfswrap_fchown,
+               vfswrap_chdir,
+               vfswrap_getwd,
+               vfswrap_utime,
+               vfswrap_ftruncate,
+               vfswrap_lock,
+               vfswrap_symlink,
+               vfswrap_readlink,
+               vfswrap_link,
+               vfswrap_mknod,
+               vfswrap_realpath,
+       
+               vfswrap_fget_nt_acl,
+               vfswrap_get_nt_acl,
+               vfswrap_fset_nt_acl,
+               vfswrap_set_nt_acl,
+       
+               /* POSIX ACL operations. */
 #if defined(HAVE_NO_ACLS)
-       NULL,
-       NULL,
+               NULL,
+               NULL,
 #else
-       vfswrap_chmod_acl,
-       vfswrap_fchmod_acl,
+               vfswrap_chmod_acl,
+               vfswrap_fchmod_acl,
 #endif
-       vfswrap_sys_acl_get_entry,
-       vfswrap_sys_acl_get_tag_type,
-       vfswrap_sys_acl_get_permset,
-       vfswrap_sys_acl_get_qualifier,
-       vfswrap_sys_acl_get_file,
-       vfswrap_sys_acl_get_fd,
-       vfswrap_sys_acl_clear_perms,
-       vfswrap_sys_acl_add_perm,
-       vfswrap_sys_acl_to_text,
-       vfswrap_sys_acl_init,
-       vfswrap_sys_acl_create_entry,
-       vfswrap_sys_acl_set_tag_type,
-       vfswrap_sys_acl_set_qualifier,
-       vfswrap_sys_acl_set_permset,
-       vfswrap_sys_acl_valid,
-       vfswrap_sys_acl_set_file,
-       vfswrap_sys_acl_set_fd,
-       vfswrap_sys_acl_delete_def_file,
-       vfswrap_sys_acl_get_perm,
-       vfswrap_sys_acl_free_text,
-       vfswrap_sys_acl_free_acl,
-       vfswrap_sys_acl_free_qualifier
+               vfswrap_sys_acl_get_entry,
+               vfswrap_sys_acl_get_tag_type,
+               vfswrap_sys_acl_get_permset,
+               vfswrap_sys_acl_get_qualifier,
+               vfswrap_sys_acl_get_file,
+               vfswrap_sys_acl_get_fd,
+               vfswrap_sys_acl_clear_perms,
+               vfswrap_sys_acl_add_perm,
+               vfswrap_sys_acl_to_text,
+               vfswrap_sys_acl_init,
+               vfswrap_sys_acl_create_entry,
+               vfswrap_sys_acl_set_tag_type,
+               vfswrap_sys_acl_set_qualifier,
+               vfswrap_sys_acl_set_permset,
+               vfswrap_sys_acl_valid,
+               vfswrap_sys_acl_set_file,
+               vfswrap_sys_acl_set_fd,
+               vfswrap_sys_acl_delete_def_file,
+               vfswrap_sys_acl_get_perm,
+               vfswrap_sys_acl_free_text,
+               vfswrap_sys_acl_free_acl,
+               vfswrap_sys_acl_free_qualifier
+       }
 };
 
 /****************************************************************************
@@ -140,52 +138,49 @@ static struct vfs_ops default_vfs_ops = {
 
 static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
 {
-   struct vfs_init_function_entry *entry = backends;
-   pstring stripped;
-
-   module_path_get_name(name, stripped);
+       struct vfs_init_function_entry *entry = backends;
+       pstring stripped;
 
-   while(entry) {
-       if (strequal(entry->name, stripped)) return entry;
-       entry = entry->next;
-   }
+       module_path_get_name(name, stripped);
+       while(entry) {
+               if (strequal(entry->name, stripped)) return entry;
+               entry = entry->next;
+       }
 
-   return NULL;
+       return NULL;
 }
 
-NTSTATUS smb_register_vfs(int version, const char *name, vfs_op_tuple *(*init)(const struct vfs_ops *, struct smb_vfs_handle_struct *))
+NTSTATUS smb_register_vfs(int version, const char *name, vfs_op_tuple *vfs_op_tuples)
 {
-   struct vfs_init_function_entry *entry = backends;
-
-   if ((version < SMB_VFS_INTERFACE_CASCADED)) {
-       DEBUG(0, ("vfs_init() returned wrong interface version info (was %d, should be no less than %d)\n",
-           version, SMB_VFS_INTERFACE_VERSION ));
-       return NT_STATUS_OBJECT_TYPE_MISMATCH;
-   }
-  
-   if ((version < SMB_VFS_INTERFACE_VERSION)) {
-       DEBUG(0, ("Warning: vfs_init() states that module confirms interface version #%d, current interface version is #%d.\n\
-               Proceeding in compatibility mode, new operations (since version #%d) will fallback to default ones.\n",
-               version, SMB_VFS_INTERFACE_VERSION, version ));
-          return NT_STATUS_OBJECT_TYPE_MISMATCH;
-   }
-
-   if (!name || !init) {
-       return NT_STATUS_INVALID_PARAMETER;
-   }
-   
-   if (vfs_find_backend_entry(name)) {
-           DEBUG(0,("VFS module %s already loaded!\n", name));
-           return NT_STATUS_OBJECT_NAME_COLLISION;
-   }
-
-   entry = smb_xmalloc(sizeof(struct vfs_init_function_entry));
-   entry->name = smb_xstrdup(name);
-   entry->init = init;
-
-   DLIST_ADD(backends, entry);
-   DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
-   return NT_STATUS_OK;
+       struct vfs_init_function_entry *entry = backends;
+
+       if ((version != SMB_VFS_INTERFACE_VERSION)) {
+               DEBUG(0, ("Failed to register vfs module.\n"
+                         "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
+                         "current SMB_VFS_INTERFACE_VERSION is %d.\n"
+                         "Please recompile against the current Samba Version!\n",  
+                         version, SMB_VFS_INTERFACE_VERSION));
+               return NT_STATUS_OBJECT_TYPE_MISMATCH;
+       }
+
+       if (!name || !name[0] || !vfs_op_tuples) {
+               DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
+               return NT_STATUS_INVALID_PARAMETER;
+       }
+
+       if (vfs_find_backend_entry(name)) {
+               DEBUG(0,("VFS module %s already loaded!\n", name));
+               return NT_STATUS_OBJECT_NAME_COLLISION;
+       }
+
+       entry = smb_xmalloc(sizeof(struct vfs_init_function_entry));
+       entry->name = smb_xstrdup(name);
+       entry->vfs_op_tuples = vfs_op_tuples;
+
+       DLIST_ADD(backends, entry);
+       DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
+       return NT_STATUS_OK;
 }
 
 /****************************************************************************
@@ -196,62 +191,10 @@ static void vfs_init_default(connection_struct *conn)
 {
        DEBUG(3, ("Initialising default vfs hooks\n"));
 
-       memcpy(&conn->vfs_ops, &default_vfs_ops, sizeof(struct vfs_ops));
-       conn->vfs_private = NULL;
+       memcpy(&conn->vfs.ops, &default_vfs.ops, sizeof(default_vfs.ops));
+       memcpy(&conn->vfs_opaque.ops, &default_vfs.ops, sizeof(default_vfs.ops));
 }
 
-/***************************************************************************
- Function to load old VFS modules. Should go away after a while.
- **************************************************************************/
-
-static vfs_op_tuple *vfs_load_old_plugin(connection_struct *conn, const char *vfs_object)
-{
-       int vfs_version = -1;
-       vfs_op_tuple *ops, *(*init_fptr)(int *, const struct vfs_ops *, struct smb_vfs_handle_struct *);
-       /* Open object file */
-
-       if ((conn->vfs_private->handle = sys_dlopen(vfs_object, RTLD_NOW)) == NULL) {
-               DEBUG(0, ("Error opening %s: %s\n", vfs_object, sys_dlerror()));
-               return NULL;
-       }
-
-       /* Get handle on vfs_init() symbol */
-
-       init_fptr = (vfs_op_tuple *(*)(int *, const struct vfs_ops *, struct smb_vfs_handle_struct *))sys_dlsym(conn->vfs_private->handle, "vfs_init");
-
-       if (init_fptr == NULL) {
-               DEBUG(0, ("No vfs_init() symbol found in %s\n", vfs_object));
-               sys_dlclose(conn->vfs_private->handle);
-               return NULL;
-       }
-
-       /* Initialise vfs_ops structure */
-       if ((ops = init_fptr(&vfs_version, &conn->vfs_ops, conn->vfs_private)) == NULL) {
-               DEBUG(0, ("vfs_init() function from %s failed\n", vfs_object));
-               sys_dlclose(conn->vfs_private->handle);
-               return NULL;
-       }
-
-       if ((vfs_version < SMB_VFS_INTERFACE_CASCADED)) {
-               DEBUG(0, ("vfs_init() returned wrong interface version info (was %d, should be no less than %d)\n",
-                                 vfs_version, SMB_VFS_INTERFACE_VERSION ));
-               sys_dlclose(conn->vfs_private->handle);
-               return NULL;
-       }
-
-       if ((vfs_version < SMB_VFS_INTERFACE_VERSION)) {
-               DEBUG(0, ("Warning: vfs_init() states that module confirms interface version #%d, current interface version is #%d.\n\
-                                 Proceeding in compatibility mode, new operations (since version #%d) will fallback to default ones.\n",
-                                 vfs_version, SMB_VFS_INTERFACE_VERSION, vfs_version ));
-               sys_dlclose(conn->vfs_private->handle);
-               return NULL;
-       }
-       
-       return ops;
-}
-
-
-
 /****************************************************************************
   initialise custom vfs hooks
  ****************************************************************************/
@@ -259,51 +202,82 @@ static vfs_op_tuple *vfs_load_old_plugin(connection_struct *conn, const char *vf
 BOOL vfs_init_custom(connection_struct *conn, const char *vfs_object)
 {
        vfs_op_tuple *ops;
+       char *module_name = NULL;
+       char *module_param = NULL, *p;
        int i;
+       vfs_handle_struct *handle;
        struct vfs_init_function_entry *entry;
-
-       DEBUG(3, ("Initialising custom vfs hooks from %s\n", vfs_object));
+       
+       if (!conn||!vfs_object||!vfs_object[0]) {
+               DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
+               return False;
+       }
 
        if(!backends) static_init_vfs;
 
+       DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
+
+       module_name = smb_xstrdup(vfs_object);
+
+       p = strchr(module_name, ':');
+
+       if (p) {
+               *p = 0;
+               module_param = p+1;
+               trim_string(module_param, " ", " ");
+       }
+
+       trim_string(module_name, " ", " ");
+
        /* First, try to load the module with the new module system */
-       if((entry = vfs_find_backend_entry(vfs_object)) || 
-          (NT_STATUS_IS_OK(smb_probe_module("vfs", vfs_object)) && 
-               (entry = vfs_find_backend_entry(vfs_object)))) {
+       if((entry = vfs_find_backend_entry(module_name)) || 
+          (NT_STATUS_IS_OK(smb_probe_module("vfs", module_name)) && 
+               (entry = vfs_find_backend_entry(module_name)))) {
 
-               DEBUG(3,("Successfully loaded %s with the new modules system\n", vfs_object));
+               DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
                
-               if ((ops = entry->init(&conn->vfs_ops, conn->vfs_private)) == NULL) {
-                       DEBUG(0, ("vfs init function from %s failed\n", vfs_object));
-                       return False;
-               }
+               if ((ops = entry->vfs_op_tuples) == NULL) {
+                       DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object));
+                       SAFE_FREE(module_name);
+                       return False;
+               }
        } else {
-               /* If that doesn't work, fall back to the old system 
-                * (This part should go away after a while, it's only here 
-                * for backwards compatibility) */
-               DEBUG(2, ("Can't load module %s with new modules system, falling back to compatibility\n",
-                       vfs_object));
-               if ((ops = vfs_load_old_plugin(conn, vfs_object)) == NULL) {
-                       DEBUG(0, ("vfs init function from %s failed\n", vfs_object));
-                       return False;
-               }
+               DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
+               SAFE_FREE(module_name);
+               return False;
+       }
+
+       handle = (vfs_handle_struct *)talloc_zero(conn->mem_ctx,sizeof(vfs_handle_struct));
+       if (!handle) {
+               DEBUG(0,("talloc_zero() failed!\n"));
+               SAFE_FREE(module_name);
+               return False;
        }
+       memcpy(&handle->vfs_next, &conn->vfs, sizeof(struct vfs_ops));
+       handle->conn = conn;
+       if (module_param) {
+               handle->param = talloc_strdup(conn->mem_ctx, module_param);
+       }
+       DLIST_ADD(conn->vfs_handles, handle);
 
        for(i=0; ops[i].op != NULL; i++) {
-         DEBUG(3, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
+         DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
          if(ops[i].layer == SMB_VFS_LAYER_OPAQUE) {
            /* Check whether this operation was already made opaque by different module */
-           if(vfs_opaque_ops[ops[i].type].op == ((void**)&default_vfs_ops)[ops[i].type]) {
+           if(((void**)&conn->vfs_opaque.ops)[ops[i].type] == ((void**)&default_vfs.ops)[ops[i].type]) {
              /* No, it isn't overloaded yet. Overload. */
-             DEBUG(3, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
-             vfs_opaque_ops[ops[i].type] = ops[i];
+             DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
+             ((void**)&conn->vfs_opaque.ops)[ops[i].type] = ops[i].op;
+             ((vfs_handle_struct **)&conn->vfs_opaque.handles)[ops[i].type] = handle;
            }
          }
          /* Change current VFS disposition*/
-         DEBUG(3, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
-         ((void**)&conn->vfs_ops)[ops[i].type] = ops[i].op;
+         DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
+         ((void**)&conn->vfs.ops)[ops[i].type] = ops[i].op;
+         ((vfs_handle_struct **)&conn->vfs.handles)[ops[i].type] = handle;
        }
 
+       SAFE_FREE(module_name);
        return True;
 }
 
@@ -314,70 +288,30 @@ BOOL vfs_init_custom(connection_struct *conn, const char *vfs_object)
 BOOL smbd_vfs_init(connection_struct *conn)
 {
        const char **vfs_objects;
-       char *vfs_module, *vfs_path;
        unsigned int i = 0;
        int j = 0;
-       struct smb_vfs_handle_struct *handle;
        
        /* Normal share - initialise with disk access functions */
        vfs_init_default(conn);
-       vfs_objects = lp_vfsobj(SNUM(conn));
+       vfs_objects = lp_vfs_objects(SNUM(conn));
 
        /* Override VFS functions if 'vfs object' was not specified*/
        if (!vfs_objects || !vfs_objects[0])
                return True;
-
-       for(i=0; i<SMB_VFS_OP_LAST; i++) {
-               vfs_opaque_ops[i].op = ((void**)&default_vfs_ops)[i];
-               vfs_opaque_ops[i].type = i;
-               vfs_opaque_ops[i].layer = SMB_VFS_LAYER_OPAQUE;
+       
+       for (i=0; vfs_objects[i] ;) {
+               i++;
        }
 
-       vfs_path = lp_vfs_path(SNUM(conn));
-       
-       for (i=0; vfs_objects[i]; i++); /* count passed modules */
-        
        for (j=i-1; j >= 0; j--) {
-               conn->vfs_private = NULL;
-               handle = (struct smb_vfs_handle_struct *) smb_xmalloc(sizeof(smb_vfs_handle_struct));
-               /* Loadable object file */
-               handle->handle = NULL;
-               DLIST_ADD(conn->vfs_private, handle);
-               vfs_module = NULL;
-               if (vfs_path && *vfs_path) {
-                       asprintf(&vfs_module, "%s/%s", vfs_path, vfs_objects[j]);
-               } else {
-                       asprintf(&vfs_module, "%s", vfs_objects[j]);
-               }
-               if (!vfs_init_custom(conn, vfs_module)) {
-                       DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_module));
-                       SAFE_FREE(vfs_module);
-                       DLIST_REMOVE(conn->vfs_private, handle);
-                       SAFE_FREE(handle);
+               if (!vfs_init_custom(conn, vfs_objects[j])) {
+                       DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
                        return False;
                }
-               SAFE_FREE(vfs_module);
        }
        return True;
 }
 
-/*******************************************************************
- Create vfs_ops reflecting current vfs_opaque_ops
-*******************************************************************/
-
-struct vfs_ops *smb_vfs_get_opaque_ops(void)
-{
-  int i;
-  struct vfs_ops *ops;
-
-  ops = smb_xmalloc(sizeof(struct vfs_ops));
-
-  for(i=0; i<SMB_VFS_OP_LAST; i++) {
-    ((void**)ops)[i] = vfs_opaque_ops[i].op;
-  }
-  return ops;
-}
-
 /*******************************************************************
  Check if directory exists.
 ********************************************************************/
@@ -390,7 +324,7 @@ BOOL vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_
        if (!st)
                st = &st2;
 
-       if (vfs_stat(conn,dname,st) != 0)
+       if (VFS_STAT(conn,dname,st) != 0)
                return(False);
 
        ret = S_ISDIR(st->st_mode);
@@ -400,25 +334,16 @@ BOOL vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_
        return ret;
 }
 
-/*******************************************************************
- vfs getwd wrapper 
-********************************************************************/
-
-static char *vfs_getwd(connection_struct *conn, char *path)
-{
-       return conn->vfs_ops.getwd(conn,path);
-}
-
 /*******************************************************************
  vfs mkdir wrapper 
 ********************************************************************/
 
-int vfs_mkdir(connection_struct *conn, const char *name, mode_t mode)
+int vfs_MkDir(connection_struct *conn, const char *name, mode_t mode)
 {
        int ret;
        SMB_STRUCT_STAT sbuf;
 
-       if(!(ret=conn->vfs_ops.mkdir(conn,name,mode))) {
+       if(!(ret=VFS_MKDIR(conn, name, mode))) {
 
                inherit_access_acl(conn, name, mode);
 
@@ -428,8 +353,8 @@ int vfs_mkdir(connection_struct *conn, const char *name, mode_t mode)
                 * Consider bits automagically set by UNIX, i.e. SGID bit from parent dir.
                 */
                if(mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) &&
-                               !vfs_stat(conn,name,&sbuf) && (mode & ~sbuf.st_mode))
-                       vfs_chmod(conn,name,sbuf.st_mode | (mode & ~sbuf.st_mode));
+                               !VFS_STAT(conn,name,&sbuf) && (mode & ~sbuf.st_mode))
+                       VFS_CHMOD(conn,name,sbuf.st_mode | (mode & ~sbuf.st_mode));
        }
        return ret;
 }
@@ -447,7 +372,7 @@ BOOL vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT
 
        ZERO_STRUCTP(sbuf);
 
-       if (vfs_stat(conn,fname,sbuf) == -1)
+       if (VFS_STAT(conn,fname,sbuf) == -1)
                return(False);
        return True;
 }
@@ -465,7 +390,7 @@ BOOL vfs_file_exist(connection_struct *conn, const char *fname,SMB_STRUCT_STAT *
 
        ZERO_STRUCTP(sbuf);
 
-       if (vfs_stat(conn,fname,sbuf) == -1)
+       if (VFS_STAT(conn,fname,sbuf) == -1)
                return False;
        return(S_ISREG(sbuf->st_mode));
 }
@@ -480,7 +405,7 @@ ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count)
 
        while (total < byte_count)
        {
-               ssize_t ret = fsp->conn->vfs_ops.read(fsp, fsp->fd, buf + total,
+               ssize_t ret = VFS_READ(fsp, fsp->fd, buf + total,
                                        byte_count - total);
 
                if (ret == 0) return total;
@@ -505,7 +430,7 @@ ssize_t vfs_write_data(files_struct *fsp,const char *buffer,size_t N)
        ssize_t ret;
 
        while (total < N) {
-               ret = fsp->conn->vfs_ops.write(fsp,fsp->fd,buffer + total,N - total);
+               ret = VFS_WRITE(fsp,fsp->fd,buffer + total,N - total);
 
                if (ret == -1)
                        return -1;
@@ -528,7 +453,6 @@ int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
        int ret;
        SMB_STRUCT_STAT st;
        connection_struct *conn = fsp->conn;
-       struct vfs_ops *vfs_ops = &conn->vfs_ops;
        SMB_BIG_UINT space_avail;
        SMB_BIG_UINT bsize,dfree,dsize;
 
@@ -545,7 +469,7 @@ int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
                return -1;
        }
 
-       ret = vfs_fstat(fsp,fsp->fd,&st);
+       ret = VFS_FSTAT(fsp,fsp->fd,&st);
        if (ret == -1)
                return ret;
 
@@ -559,7 +483,7 @@ int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
                                fsp->fsp_name, (double)st.st_size ));
 
                flush_write_cache(fsp, SIZECHANGE_FLUSH);
-               if ((ret = vfs_ops->ftruncate(fsp, fsp->fd, (SMB_OFF_T)len)) != -1) {
+               if ((ret = VFS_FTRUNCATE(fsp, fsp->fd, (SMB_OFF_T)len)) != -1) {
                        set_filelen_write_cache(fsp, len);
                }
                return ret;
@@ -572,7 +496,7 @@ int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
 
        len -= st.st_size;
        len /= 1024; /* Len is now number of 1k blocks needed. */
-       space_avail = conn->vfs_ops.disk_free(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
+       space_avail = VFS_DISK_FREE(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
 
        DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
                        fsp->fsp_name, (double)st.st_size, (double)len, (double)space_avail ));
@@ -598,7 +522,7 @@ int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len)
        release_level_2_oplocks_on_change(fsp);
        DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp->fsp_name, (double)len));
        flush_write_cache(fsp, SIZECHANGE_FLUSH);
-       if ((ret = fsp->conn->vfs_ops.ftruncate(fsp, fsp->fd, len)) != -1)
+       if ((ret = VFS_FTRUNCATE(fsp, fsp->fd, len)) != -1)
                set_filelen_write_cache(fsp, len);
 
        return ret;
@@ -613,12 +537,12 @@ static files_struct *out_fsp;
 
 static ssize_t read_fn(int fd, void *buf, size_t len)
 {
-       return in_fsp->conn->vfs_ops.read(in_fsp, fd, buf, len);
+       return VFS_READ(in_fsp, fd, buf, len);
 }
 
 static ssize_t write_fn(int fd, const void *buf, size_t len)
 {
-       return out_fsp->conn->vfs_ops.write(out_fsp, fd, buf, len);
+       return VFS_WRITE(out_fsp, fd, buf, len);
 }
 
 SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
@@ -635,13 +559,13 @@ SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
 
 char *vfs_readdirname(connection_struct *conn, void *p)
 {
-       struct dirent *ptr;
+       struct dirent *ptr= NULL;
        char *dname;
 
        if (!p)
                return(NULL);
 
-       ptr = (struct dirent *)conn->vfs_ops.readdir(conn,p);
+       ptr = (struct dirent *)VFS_READDIR(conn,p);
        if (!ptr)
                return(NULL);
 
@@ -660,72 +584,6 @@ char *vfs_readdirname(connection_struct *conn, void *p)
        return(dname);
 }
 
-/* VFS options not quite working yet */
-
-#if 0
-
-/***************************************************************************
-  handle the interpretation of the vfs option parameter
- *************************************************************************/
-static BOOL handle_vfs_option(char *pszParmValue, char **ptr)
-{
-    struct vfs_options *new_option, **options = (struct vfs_options **)ptr;
-    int i;
-
-    /* Create new vfs option */
-
-    new_option = (struct vfs_options *)malloc(sizeof(*new_option));
-    if (new_option == NULL) {
-       return False;
-    }
-
-    ZERO_STRUCTP(new_option);
-
-    /* Get name and value */
-
-    new_option->name = strtok(pszParmValue, "=");
-
-    if (new_option->name == NULL) {
-       return False;
-    }
-
-    while(isspace(*new_option->name)) {
-       new_option->name++;
-    }
-
-    for (i = strlen(new_option->name); i > 0; i--) {
-       if (!isspace(new_option->name[i - 1])) break;
-    }
-
-    new_option->name[i] = '\0';
-    new_option->name = strdup(new_option->name);
-
-    new_option->value = strtok(NULL, "=");
-
-    if (new_option->value != NULL) {
-
-       while(isspace(*new_option->value)) {
-           new_option->value++;
-       }
-       
-       for (i = strlen(new_option->value); i > 0; i--) {
-           if (!isspace(new_option->value[i - 1])) break;
-       }
-       
-       new_option->value[i] = '\0';
-       new_option->value = strdup(new_option->value);
-    }
-
-    /* Add to list */
-
-    DLIST_ADD(*options, new_option);
-
-    return True;
-}
-
-#endif
-
-
 /*******************************************************************
  A wrapper for vfs_chdir().
 ********************************************************************/
@@ -741,9 +599,9 @@ int vfs_ChDir(connection_struct *conn, const char *path)
        if (*path == '/' && strcsequal(LastDir,path))
                return(0);
 
-       DEBUG(3,("vfs_ChDir to %s\n",path));
+       DEBUG(4,("vfs_ChDir to %s\n",path));
 
-       res = vfs_chdir(conn,path);
+       res = VFS_CHDIR(conn,path);
        if (!res)
                pstrcpy(LastDir,path);
        return(res);
@@ -800,7 +658,7 @@ char *vfs_GetWd(connection_struct *conn, char *path)
        *s = 0;
 
        if (!use_getwd_cache)
-               return(vfs_getwd(conn,path));
+               return(VFS_GETWD(conn,path));
 
        /* init the cache */
        if (!getwd_cache_init) {
@@ -814,9 +672,9 @@ char *vfs_GetWd(connection_struct *conn, char *path)
        /*  Get the inode of the current directory, if this doesn't work we're
                in trouble :-) */
 
-       if (vfs_stat(conn, ".",&st) == -1) {
+       if (VFS_STAT(conn, ".",&st) == -1) {
                DEBUG(0,("Very strange, couldn't stat \".\" path=%s\n", path));
-               return(vfs_getwd(conn,path));
+               return(VFS_GETWD(conn,path));
        }
 
 
@@ -830,7 +688,7 @@ char *vfs_GetWd(connection_struct *conn, char *path)
                                the same...) */
 
                        if (st.st_ino == ino_list[i].inode && st.st_dev == ino_list[i].dev) {
-                               if (vfs_stat(conn,ino_list[i].dos_path,&st2) == 0) {
+                               if (VFS_STAT(conn,ino_list[i].dos_path,&st2) == 0) {
                                        if (st.st_ino == st2.st_ino && st.st_dev == st2.st_dev &&
                                                        (st2.st_mode & S_IFMT) == S_IFDIR) {
                                                pstrcpy (path, ino_list[i].dos_path);
@@ -852,8 +710,8 @@ char *vfs_GetWd(connection_struct *conn, char *path)
                The very slow getcwd, which spawns a process on some systems, or the
                not quite so bad getwd. */
 
-       if (!vfs_getwd(conn,s)) {
-               DEBUG(0,("vfs_GetWd: vfs_getwd call failed, errno %s\n",strerror(errno)));
+       if (!VFS_GETWD(conn,s)) {
+               DEBUG(0,("vfs_GetWd: VFS_GETWD call failed, errno %s\n",strerror(errno)));
                return (NULL);
        }
 
@@ -909,7 +767,7 @@ static BOOL readlink_check(connection_struct *conn, const char *dir, char *name)
                realdir[reallen] = 0;
        }
 
-       if (conn->vfs_ops.readlink(conn, name, flink, sizeof(pstring) -1) != -1) {
+       if (VFS_READLINK(conn, name, flink, sizeof(pstring) -1) != -1) {
                DEBUG(3,("reduce_name: file path name %s is a symlink\nChecking it's path\n", name));
                if (*flink == '/') {
                        pstrcpy(cleanlink, flink);
index b90c53e9fe36f5ccefeecdf0862ce0e34c063524..ee71b83471ee4eb4eb5071cf190718e5ebd7b38f 100644 (file)
 #include "includes.h"
 #include "vfstest.h"
 
-static char *null_string = "";
+static const char *null_string = "";
 
-static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_load_module(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-       struct smb_vfs_handle_struct *handle;
-       char *path = lp_vfs_path(0);
-       char name[PATH_MAX];
+       int i;
        
-       if (argc != 2) {
-               printf("Usage: load <module path>\n");
+       if (argc < 2) {
+               printf("Usage: load <modules>\n");
                return NT_STATUS_OK;
        }
 
-       if (path != NULL && *path != '\0') {
-               snprintf(name, PATH_MAX, "%s/%s", path, argv[1]);
-       } else {
-               snprintf(name, PATH_MAX, "%s", argv[1]);
-       }
-       vfs->conn->vfs_private = NULL;
-       handle = (struct smb_vfs_handle_struct *) smb_xmalloc(sizeof(smb_vfs_handle_struct));
-       handle->handle = NULL;
-       DLIST_ADD(vfs->conn->vfs_private, handle)
-       if (!vfs_init_custom(vfs->conn, name)) {
-               DEBUG(0, ("load: error=-1 (vfs_init_custom failed for %s)\n", argv[1]));
-               return NT_STATUS_UNSUCCESSFUL;
+       for (i=argc-1;i>0;i--) {
+               if (!vfs_init_custom(vfs->conn, argv[i])) {
+                       DEBUG(0, ("load: (vfs_init_custom failed for %s)\n", argv[i]));
+                       return NT_STATUS_UNSUCCESSFUL;
+               }
        }
        printf("load: ok\n");
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        char c;
        size_t size;
@@ -73,7 +64,7 @@ static NTSTATUS cmd_populate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        size_t offset;
        size_t len;
@@ -101,19 +92,19 @@ static NTSTATUS cmd_show_data(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int ar
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_connect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-       vfs->conn->vfs_ops.connect(vfs->conn, lp_servicename(vfs->conn->service), "vfstest");
+       VFS_CONNECT(vfs->conn, lp_servicename(vfs->conn->service), "vfstest");
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_disconnect(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-       vfs->conn->vfs_ops.disconnect(vfs->conn);
+       VFS_DISCONNECT(vfs->conn);
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        SMB_BIG_UINT diskfree, bsize, dfree, dsize;
        if (argc != 2) {
@@ -121,7 +112,7 @@ static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int ar
                return NT_STATUS_OK;
        }
 
-       diskfree = vfs->conn->vfs_ops.disk_free(vfs->conn, argv[1], False, &bsize, &dfree, &dsize);
+       diskfree = VFS_DISK_FREE(vfs->conn, argv[1], False, &bsize, &dfree, &dsize);
        printf("disk_free: %lu, bsize = %lu, dfree = %lu, dsize = %lu\n",
                        (unsigned long)diskfree,
                        (unsigned long)bsize,
@@ -131,14 +122,14 @@ static NTSTATUS cmd_disk_free(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int ar
 }
 
 
-static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        if (argc != 2) {
                printf("Usage: opendir <fname>\n");
                return NT_STATUS_OK;
        }
 
-       vfs->currentdir = vfs->conn->vfs_ops.opendir(vfs->conn, argv[1]);
+       vfs->currentdir = VFS_OPENDIR(vfs->conn, argv[1]);
        if (vfs->currentdir == NULL) {
                printf("opendir error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -149,7 +140,7 @@ static NTSTATUS cmd_opendir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc
 }
 
 
-static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        struct dirent *dent;
 
@@ -158,7 +149,7 @@ static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc
                return NT_STATUS_UNSUCCESSFUL;
        }
 
-       dent = vfs->conn->vfs_ops.readdir(vfs->conn, vfs->currentdir);
+       dent = VFS_READDIR(vfs->conn, vfs->currentdir);
        if (dent == NULL) {
                printf("readdir: NULL\n");
                return NT_STATUS_OK;
@@ -169,14 +160,14 @@ static NTSTATUS cmd_readdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc
 }
 
 
-static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        if (argc != 2) {
                printf("Usage: mkdir <path>\n");
                return NT_STATUS_OK;
        }
 
-       if (vfs->conn->vfs_ops.mkdir(vfs->conn, argv[1], 00755) == -1) {
+       if (VFS_MKDIR(vfs->conn, argv[1], 00755) == -1) {
                printf("mkdir error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -186,7 +177,7 @@ static NTSTATUS cmd_mkdir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int ret;
        
@@ -195,7 +186,7 @@ static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg
                return NT_STATUS_UNSUCCESSFUL;
        }
 
-       ret = vfs->conn->vfs_ops.closedir(vfs->conn, vfs->currentdir);
+       ret = VFS_CLOSEDIR(vfs->conn, vfs->currentdir);
        if (ret == -1) {
                printf("closedir failure: %s\n", strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -207,11 +198,11 @@ static NTSTATUS cmd_closedir(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg
 }
 
 
-static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int flags, fd;
        mode_t mode;
-       char *flagstr;
+       const char *flagstr;
 
        mode = 00400;
 
@@ -287,7 +278,7 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
                }
        }
 
-       fd = vfs->conn->vfs_ops.open(vfs->conn, argv[1], flags, mode);
+       fd = VFS_OPEN(vfs->conn, argv[1], flags, mode);
        if (fd == -1) {
                printf("open: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -302,7 +293,7 @@ static NTSTATUS cmd_open(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
 }
 
 
-static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int ret = -1;
 
@@ -312,11 +303,11 @@ static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg
        }
 
        if (strcmp("rmdir", argv[0]) == 0 ) {
-               ret = vfs->conn->vfs_ops.rmdir(vfs->conn, argv[1]);
+               ret = VFS_RMDIR(vfs->conn, argv[1]);
        } else if (strcmp("unlink", argv[0]) == 0 ) {
-               ret = vfs->conn->vfs_ops.unlink(vfs->conn, argv[1]);
+               ret = VFS_UNLINK(vfs->conn, argv[1]);
        } else if (strcmp("chdir", argv[0]) == 0 ) {
-               ret = vfs->conn->vfs_ops.chdir(vfs->conn, argv[1]);
+               ret = VFS_CHDIR(vfs->conn, argv[1]);
        } else {
                printf("%s: error=%d (invalid function name!)\n", argv[0], errno);
                return NT_STATUS_UNSUCCESSFUL;
@@ -332,7 +323,7 @@ static NTSTATUS cmd_pathfunc(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int arg
 }
 
 
-static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd, ret;
 
@@ -347,7 +338,7 @@ static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_OK;
        }
 
-       ret = vfs->conn->vfs_ops.close(vfs->files[fd], fd);
+       ret = VFS_CLOSE(vfs->files[fd], fd);
        if (ret == -1 )
                printf("close: error=%d (%s)\n", errno, strerror(errno));
        else
@@ -360,7 +351,7 @@ static NTSTATUS cmd_close(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd;
        size_t size, rsize;
@@ -380,7 +371,7 @@ static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
        }
        vfs->data_size = size;
        
-       rsize = vfs->conn->vfs_ops.read(vfs->files[fd], fd, vfs->data, size);
+       rsize = VFS_READ(vfs->files[fd], fd, vfs->data, size);
        if (rsize == -1) {
                printf("read: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -391,7 +382,7 @@ static NTSTATUS cmd_read(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
 }
 
 
-static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd, size, wsize;
 
@@ -413,7 +404,7 @@ static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_UNSUCCESSFUL;
        }
 
-       wsize = vfs->conn->vfs_ops.write(vfs->files[fd], fd, vfs->data, size);
+       wsize = VFS_WRITE(vfs->files[fd], fd, vfs->data, size);
 
        if (wsize == -1) {
                printf("write: error=%d (%s)\n", errno, strerror(errno));
@@ -425,7 +416,7 @@ static NTSTATUS cmd_write(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd, offset, whence;
        SMB_OFF_T pos;
@@ -444,7 +435,7 @@ static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                default:        whence = SEEK_END;
        }
 
-       pos = vfs->conn->vfs_ops.lseek(vfs->files[fd], fd, offset, whence);
+       pos = VFS_LSEEK(vfs->files[fd], fd, offset, whence);
        if (pos == (SMB_OFF_T)-1) {
                printf("lseek: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -455,7 +446,7 @@ static NTSTATUS cmd_lseek(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int ret;
        if (argc != 3) {
@@ -463,7 +454,7 @@ static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_OK;
        }
 
-       ret = vfs->conn->vfs_ops.rename(vfs->conn, argv[1], argv[2]);
+       ret = VFS_RENAME(vfs->conn, argv[1], argv[2]);
        if (ret == -1) {
                printf("rename: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -474,7 +465,7 @@ static NTSTATUS cmd_rename(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int ret, fd;
        if (argc != 2) {
@@ -483,7 +474,7 @@ static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        }
 
        fd = atoi(argv[1]);
-       ret = vfs->conn->vfs_ops.fsync(vfs->files[fd], fd);
+       ret = VFS_FSYNC(vfs->files[fd], fd);
        if (ret == -1) {
                printf("fsync: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
@@ -494,11 +485,11 @@ static NTSTATUS cmd_fsync(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int ret;
-       char *user;
-       char *group;
+       const char *user;
+       const char *group;
        struct passwd *pwd;
        struct group *grp;
        SMB_STRUCT_STAT st;
@@ -508,17 +499,17 @@ static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
                return NT_STATUS_OK;
        }
 
-       ret = vfs->conn->vfs_ops.stat(vfs->conn, argv[1], &st);
+       ret = VFS_STAT(vfs->conn, argv[1], &st);
        if (ret == -1) {
                printf("stat: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
 
        pwd = sys_getpwuid(st.st_uid);
-       if (pwd != NULL) user = strdup(pwd->pw_name);
+       if (pwd != NULL) user = pwd->pw_name;
        else user = null_string;
        grp = sys_getgrgid(st.st_gid);
-       if (grp != NULL) group = strdup(grp->gr_name);
+       if (grp != NULL) group = grp->gr_name;
        else group = null_string;
 
        printf("stat: ok\n");
@@ -541,17 +532,17 @@ static NTSTATUS cmd_stat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, c
        printf("  Access: %s", ctime(&(st.st_atime)));
        printf("  Modify: %s", ctime(&(st.st_mtime)));
        printf("  Change: %s", ctime(&(st.st_ctime)));
-       if (user != null_string) SAFE_FREE(user);
-       if (group!= null_string) SAFE_FREE(group);
+       SAFE_FREE(pwd);
+       SAFE_FREE(grp);
        return NT_STATUS_OK;
 }
 
 
-static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd;
-       char *user;
-       char *group;
+       const char *user;
+       const char *group;
        struct passwd *pwd;
        struct group *grp;
        SMB_STRUCT_STAT st;
@@ -572,16 +563,16 @@ static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_OK;
        }
 
-       if (vfs->conn->vfs_ops.fstat(vfs->files[fd], fd, &st) == -1) {
+       if (VFS_FSTAT(vfs->files[fd], fd, &st) == -1) {
                printf("fstat: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
 
        pwd = sys_getpwuid(st.st_uid);
-       if (pwd != NULL) user = strdup(pwd->pw_name);
+       if (pwd != NULL) user = pwd->pw_name;
        else user = null_string;
        grp = sys_getgrgid(st.st_gid);
-       if (grp != NULL) group = strdup(grp->gr_name);
+       if (grp != NULL) group = grp->gr_name;
        else group = null_string;
 
        printf("fstat: ok\n");
@@ -603,16 +594,16 @@ static NTSTATUS cmd_fstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        printf("  Access: %s", ctime(&(st.st_atime)));
        printf("  Modify: %s", ctime(&(st.st_mtime)));
        printf("  Change: %s", ctime(&(st.st_ctime)));
-       if (user != null_string) SAFE_FREE(user);
-       if (group!= null_string) SAFE_FREE(group);
+       SAFE_FREE(pwd);
+       SAFE_FREE(grp);
        return NT_STATUS_OK;
 }
 
 
-static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
-       char *user;
-       char *group;
+       const char *user;
+       const char *group;
        struct passwd *pwd;
        struct group *grp;
        SMB_STRUCT_STAT st;
@@ -622,16 +613,16 @@ static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_OK;
        }
 
-       if (vfs->conn->vfs_ops.lstat(vfs->conn, argv[1], &st) == -1) {
+       if (VFS_LSTAT(vfs->conn, argv[1], &st) == -1) {
                printf("lstat: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
 
        pwd = sys_getpwuid(st.st_uid);
-       if (pwd != NULL) user = strdup(pwd->pw_name);
+       if (pwd != NULL) user = pwd->pw_name;
        else user = null_string;
        grp = sys_getgrgid(st.st_gid);
-       if (grp != NULL) group = strdup(grp->gr_name);
+       if (grp != NULL) group = grp->gr_name;
        else group = null_string;
 
        printf("lstat: ok\n");
@@ -653,13 +644,13 @@ static NTSTATUS cmd_lstat(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        printf("  Access: %s", ctime(&(st.st_atime)));
        printf("  Modify: %s", ctime(&(st.st_mtime)));
        printf("  Change: %s", ctime(&(st.st_ctime)));
-       if (user != null_string) SAFE_FREE(user);
-       if (group!= null_string) SAFE_FREE(group);
+       SAFE_FREE(pwd);
+       SAFE_FREE(grp);
        return NT_STATUS_OK;
 }
 
 
-static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        mode_t mode;
        if (argc != 3) {
@@ -668,7 +659,7 @@ static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        }
 
        mode = atoi(argv[2]);
-       if (vfs->conn->vfs_ops.chmod(vfs->conn, argv[1], mode) == -1) {
+       if (VFS_CHMOD(vfs->conn, argv[1], mode) == -1) {
                printf("chmod: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -678,7 +669,7 @@ static NTSTATUS cmd_chmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd;
        mode_t mode;
@@ -698,7 +689,7 @@ static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                return NT_STATUS_OK;
        }
 
-       if (vfs->conn->vfs_ops.fchmod(vfs->files[fd], fd, mode) == -1) {
+       if (VFS_FCHMOD(vfs->files[fd], fd, mode) == -1) {
                printf("fchmod: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -708,7 +699,7 @@ static NTSTATUS cmd_fchmod(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        uid_t uid;
        gid_t gid;
@@ -719,7 +710,7 @@ static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 
        uid = atoi(argv[2]);
        gid = atoi(argv[3]);
-       if (vfs->conn->vfs_ops.chown(vfs->conn, argv[1], uid, gid) == -1) {
+       if (VFS_CHOWN(vfs->conn, argv[1], uid, gid) == -1) {
                printf("chown: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -729,7 +720,7 @@ static NTSTATUS cmd_chown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        uid_t uid;
        gid_t gid;
@@ -750,7 +741,7 @@ static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
                printf("fchown: error=%d (invalid file descriptor)\n", EBADF);
                return NT_STATUS_OK;
        }
-       if (vfs->conn->vfs_ops.fchown(vfs->files[fd], fd, uid, gid) == -1) {
+       if (VFS_FCHOWN(vfs->files[fd], fd, uid, gid) == -1) {
                printf("fchown error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -760,10 +751,10 @@ static NTSTATUS cmd_fchown(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
 }
 
 
-static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        char buf[PATH_MAX];
-       if (vfs->conn->vfs_ops.getwd(vfs->conn, buf) == NULL) {
+       if (VFS_GETWD(vfs->conn, buf) == NULL) {
                printf("getwd: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -772,7 +763,7 @@ static NTSTATUS cmd_getwd(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        struct utimbuf times;
        if (argc != 4) {
@@ -781,7 +772,7 @@ static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        }
        times.actime = atoi(argv[2]);
        times.modtime = atoi(argv[3]);
-       if (vfs->conn->vfs_ops.utime(vfs->conn, argv[1], &times) != 0) {
+       if (VFS_UTIME(vfs->conn, argv[1], &times) != 0) {
                printf("utime: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
        }
@@ -790,7 +781,7 @@ static NTSTATUS cmd_utime(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc,
        return NT_STATUS_OK;
 }
 
-static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, char **argv)
+static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int argc, const char **argv)
 {
        int fd;
        SMB_OFF_T off;
@@ -810,7 +801,7 @@ static NTSTATUS cmd_ftruncate(struct vfs_state *vfs, TALLOC_CTX *mem_ctx, int ar
                return NT_STATUS_OK;
        }
 
-       if (vfs->conn->vfs_ops.ftruncate(vfs->files[fd], fd, off) == -1) {
+       if (VFS_FTRUNCATE(vfs->files[fd], fd, off) == -1) {
                printf("ftruncate: error=%d (%s)\n", errno, strerror(errno));
                return NT_STATUS_UNSUCCESSFUL;
   &nbs