Changeset 745 for trunk/server/source3/modules

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/modules/charset_macosxfs.c (modified) (1 diff)
• source3/modules/developer.c (modified) (1 diff)
• source3/modules/gpfs.c (modified) (6 diffs)
• source3/modules/nfs4_acls.c (modified) (27 diffs)
• source3/modules/nfs4_acls.h (modified) (3 diffs)
• source3/modules/onefs.h (modified) (2 diffs)
• source3/modules/onefs_acl.c (modified) (27 diffs)
• source3/modules/onefs_cbrl.c (modified) (7 diffs)
• source3/modules/onefs_config.c (modified) (1 diff)
• source3/modules/onefs_dir.c (modified) (1 diff)
• source3/modules/onefs_notify.c (modified) (1 diff)
• source3/modules/onefs_open.c (modified) (28 diffs)
• source3/modules/onefs_shadow_copy.c (modified) (1 diff)
• source3/modules/onefs_streams.c (modified) (1 diff)
• source3/modules/onefs_system.c (modified) (2 diffs)
• source3/modules/perfcount_onefs.c (modified) (3 diffs)
• source3/modules/perfcount_test.c (modified) (2 diffs)
• source3/modules/vfs_acl_common.c (modified) (18 diffs)
• source3/modules/vfs_acl_tdb.c (modified) (2 diffs)
• source3/modules/vfs_acl_xattr.c (modified) (3 diffs)
• source3/modules/vfs_afsacl.c (modified) (18 diffs)
• source3/modules/vfs_aio_fork.c (modified) (12 diffs)
• source3/modules/vfs_aixacl.c (modified) (1 diff)
• source3/modules/vfs_aixacl2.c (modified) (5 diffs)
• source3/modules/vfs_aixacl_util.c (modified) (1 diff)
• source3/modules/vfs_audit.c (modified) (2 diffs)
• source3/modules/vfs_cacheprime.c (modified) (1 diff)
• source3/modules/vfs_cap.c (modified) (4 diffs)
• source3/modules/vfs_catia.c (modified) (6 diffs)
• source3/modules/vfs_commit.c (modified) (3 diffs)
• source3/modules/vfs_crossrename.c (copied) (copied from vendor/current/source3/modules/vfs_crossrename.c )
• source3/modules/vfs_default.c (modified) (26 diffs)
• source3/modules/vfs_default_quota.c (modified) (1 diff)
• source3/modules/vfs_dirsort.c (modified) (8 diffs)
• source3/modules/vfs_expand_msdfs.c (modified) (6 diffs)
• source3/modules/vfs_extd_audit.c (modified) (2 diffs)
• source3/modules/vfs_fake_perms.c (modified) (3 diffs)
• source3/modules/vfs_fileid.c (modified) (1 diff)
• source3/modules/vfs_full_audit.c (modified) (28 diffs)
• source3/modules/vfs_gpfs.c (modified) (20 diffs)
• source3/modules/vfs_gpfs.h (modified) (1 diff)
• source3/modules/vfs_gpfs_hsm_notify.c (copied) (copied from vendor/current/source3/modules/vfs_gpfs_hsm_notify.c )
• source3/modules/vfs_hpuxacl.c (modified) (3 diffs)
• source3/modules/vfs_irixacl.c (modified) (1 diff)
• source3/modules/vfs_linux_xfs_sgid.c (copied) (copied from vendor/current/source3/modules/vfs_linux_xfs_sgid.c )
• source3/modules/vfs_netatalk.c (modified) (3 diffs)
• source3/modules/vfs_notify_fam.c (modified) (3 diffs)
• source3/modules/vfs_onefs.c (modified) (2 diffs)
• source3/modules/vfs_onefs_shadow_copy.c (modified) (7 diffs)
• source3/modules/vfs_posixacl.c (modified) (1 diff)
• source3/modules/vfs_prealloc.c (modified) (2 diffs)
• source3/modules/vfs_preopen.c (modified) (2 diffs)
• source3/modules/vfs_readahead.c (modified) (1 diff)
• source3/modules/vfs_readonly.c (modified) (2 diffs)
• source3/modules/vfs_recycle.c (modified) (15 diffs)
• source3/modules/vfs_scannedonly.c (modified) (11 diffs)
• source3/modules/vfs_shadow_copy.c (modified) (5 diffs)
• source3/modules/vfs_shadow_copy2.c (modified) (23 diffs)
• source3/modules/vfs_smb_traffic_analyzer.c (modified) (16 diffs)
• source3/modules/vfs_smb_traffic_analyzer.h (copied) (copied from vendor/current/source3/modules/vfs_smb_traffic_analyzer.h )
• source3/modules/vfs_solarisacl.c (modified) (1 diff)
• source3/modules/vfs_streams_depot.c (modified) (5 diffs)
• source3/modules/vfs_streams_xattr.c (modified) (3 diffs)
• source3/modules/vfs_syncops.c (modified) (8 diffs)
• source3/modules/vfs_time_audit.c (copied) (copied from vendor/current/source3/modules/vfs_time_audit.c )
• source3/modules/vfs_tru64acl.c (modified) (1 diff)
• source3/modules/vfs_tsmsm.c (modified) (6 diffs)
• source3/modules/vfs_xattr_tdb.c (modified) (7 diffs)
• source3/modules/vfs_zfsacl.c (modified) (6 diffs)
• source3/modules/weird.c (modified) (1 diff)
• source3/modules/wscript_build (copied) (copied from vendor/current/source3/modules/wscript_build )

trunk/server/source3/modules/charset_macosxfs.c

@@ -596 +596 @@
 NTSTATUS charset_macosxfs_init(void)
 {
-        return smb_register_charset(&macosxfs_encoding_functions);
+        if (!smb_register_charset(&macosxfs_encoding_functions)) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        return NT_STATUS_OK;
 }
 

trunk/server/source3/modules/developer.c

@@ -125 +125 @@
 struct charset_functions weird_functions = {"WEIRD", weird_pull, weird_push};
 
-int charset_weird_init(void)
+NTSTATUS charset_weird_init(void)
 {
-        smb_register_charset(&weird_functions);
-        return True;
+        if (!smb_register_charset(&weird_functions)) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        return NT_STATUS_OK;
 }

trunk/server/source3/modules/gpfs.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 #ifdef HAVE_GPFS
 
+#include "libcli/security/security.h"
 #include "gpfs_gpl.h"
 #include "vfs_gpfs.h"
@@ -39 +41 @@
 static int (*gpfs_get_winattrs_fn)(int fd, struct gpfs_winattr *attrs);
 static int (*gpfs_ftruncate_fn)(int fd, gpfs_off64_t length);
+static int (*gpfs_lib_init_fn)(int flags);
 
 bool set_gpfs_sharemode(files_struct *fsp, uint32 access_mask,
@@ -133 +136 @@
 }
 
-int smbd_gpfs_ftrunctate(int fd, gpfs_off64_t length)
-{
-       if (!gpfs_do_ftruncate || (gpfs_ftruncate_fn == NULL)) {
-               errno = ENOSYS;
-               return -1;
-       }
-
-       return gpfs_ftruncate_fn(fd, length);
+int smbd_gpfs_ftruncate(int fd, gpfs_off64_t length)
+{
+        if (!gpfs_do_ftruncate || (gpfs_ftruncate_fn == NULL)) {
+                errno = ENOSYS;
+                return -1;
+        }
+
+        return gpfs_ftruncate_fn(fd, length);
 }
 
@@ -186 +189 @@
         DEBUG(10, ("gpfs_set_winattrs_path:open call %s\n",pathname));
         return gpfs_set_winattrs_path_fn(pathname,flags, attrs);
+}
+
+void smbd_gpfs_lib_init()
+{
+        if (gpfs_lib_init_fn) {
+                int rc = gpfs_lib_init_fn(0);
+                DEBUG(10, ("gpfs_lib_init() finished with rc %d "
+                           "and errno %d\n", rc, errno));
+        } else {
+                DEBUG(10, ("libgpfs lacks gpfs_lib_init\n"));
+        }
 }
 
@@ -249 +263 @@
         init_gpfs_function(&gpfs_set_winattrs_path_fn,"gpfs_set_winattrs_path");
         init_gpfs_function(&gpfs_get_winattrs_fn,"gpfs_get_winattrs");
-        init_gpfs_function(&gpfs_ftruncate_fn,"gpfs_ftruncate");
+        init_gpfs_function(&gpfs_ftruncate_fn, "gpfs_ftruncate");
+        init_gpfs_function(&gpfs_lib_init_fn,"gpfs_lib_init");
 
         gpfs_getrealfilename = lp_parm_bool(-1, "gpfs", "getrealfilename",
                                             True);
         gpfs_winattr = lp_parm_bool(-1, "gpfs", "winattr", False);
-
         gpfs_do_ftruncate = lp_parm_bool(-1, "gpfs", "ftruncate", True);
 
@@ -311 +325 @@
 }
 
+void smbd_gpfs_lib_init()
+{
+        return;
+}
+
 void init_gpfs(void)
 {

trunk/server/source3/modules/nfs4_acls.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "nfs4_acls.h"
+#include "librpc/gen_ndr/ndr_security.h"
+#include "../libcli/security/dom_sid.h"
+#include "../libcli/security/security.h"
+#include "include/dbwrap.h"
+#include "system/filesys.h"
+#include "passdb/lookup_sid.h"
+#include "util_tdb.h"
 
 #undef DBGC_CLASS
@@ -45 +53 @@
 } SMB_ACL4_INT_T;
 
+/************************************************
+ Split the ACE flag mapping between nfs4 and Windows
+ into two separate functions rather than trying to do
+ it inline. Allows us to carefully control what flags
+ are mapped to what in one place.
+************************************************/
+
+static uint32_t map_nfs4_ace_flags_to_windows_ace_flags(uint32_t nfs4_ace_flags)
+{
+        uint32_t win_ace_flags = 0;
+
+        /* The nfs4 flags <= 0xf map perfectly. */
+        win_ace_flags = nfs4_ace_flags & (SEC_ACE_FLAG_OBJECT_INHERIT|
+                                      SEC_ACE_FLAG_CONTAINER_INHERIT|
+                                      SEC_ACE_FLAG_NO_PROPAGATE_INHERIT|
+                                      SEC_ACE_FLAG_INHERIT_ONLY);
+
+        /* flags greater than 0xf have diverged :-(. */
+        /* See the nfs4 ace flag definitions here:
+           http://www.ietf.org/rfc/rfc3530.txt.
+           And the Windows ace flag definitions here:
+           librpc/idl/security.idl. */
+        if (nfs4_ace_flags & SMB_ACE4_INHERITED_ACE) {
+                win_ace_flags |= SEC_ACE_FLAG_INHERITED_ACE;
+        }
+
+        return win_ace_flags;
+}
+
+static uint32_t map_windows_ace_flags_to_nfs4_ace_flags(uint32_t win_ace_flags)
+{
+        uint32_t nfs4_ace_flags = 0;
+
+        /* The windows flags <= 0xf map perfectly. */
+        nfs4_ace_flags = win_ace_flags & (SMB_ACE4_FILE_INHERIT_ACE|
+                                      SMB_ACE4_DIRECTORY_INHERIT_ACE|
+                                      SMB_ACE4_NO_PROPAGATE_INHERIT_ACE|
+                                      SMB_ACE4_INHERIT_ONLY_ACE);
+
+        /* flags greater than 0xf have diverged :-(. */
+        /* See the nfs4 ace flag definitions here:
+           http://www.ietf.org/rfc/rfc3530.txt.
+           And the Windows ace flag definitions here:
+           librpc/idl/security.idl. */
+        if (win_ace_flags & SEC_ACE_FLAG_INHERITED_ACE) {
+                nfs4_ace_flags |= SMB_ACE4_INHERITED_ACE;
+        }
+
+        return nfs4_ace_flags;
+}
+
 static SMB_ACL4_INT_T *get_validated_aclint(SMB4ACL_T *theacl)
 {
@@ -183 +242 @@
         memset(psbuf, 0, sizeof(SMB_STRUCT_STAT));
 
-        if (fsp->is_directory || fsp->fh->fd == -1) {
+        if (fsp->fh->fd == -1) {
                 return smbacl4_GetFileOwner(fsp->conn,
                                             fsp->fsp_name->base_name, psbuf);
@@ -198 +257 @@
 
 static bool smbacl4_nfs42win(TALLOC_CTX *mem_ctx, SMB4ACL_T *theacl, /* in */
-        DOM_SID *psid_owner, /* in */
-        DOM_SID *psid_group, /* in */
+        struct dom_sid *psid_owner, /* in */
+        struct dom_sid *psid_group, /* in */
         bool is_directory, /* in */
-        SEC_ACE **ppnt_ace_list, /* out */
+        struct security_ace **ppnt_ace_list, /* out */
         int *pgood_aces /* out */
 )
@@ -207 +266 @@
         SMB_ACL4_INT_T *aclint = (SMB_ACL4_INT_T *)theacl;
         SMB_ACE4_INT_T *aceint;
-        SEC_ACE *nt_ace_list = NULL;
+        struct security_ace *nt_ace_list = NULL;
         int good_aces = 0;
 
@@ -215 +274 @@
         /* We do not check for naces being 0 or theacl being NULL here because it is done upstream */
         /* in smb_get_nt_acl_nfs4(). */
-        nt_ace_list = (SEC_ACE *)TALLOC_ZERO_SIZE(mem_ctx, aclint->naces * sizeof(SEC_ACE));
+        nt_ace_list = (struct security_ace *)TALLOC_ZERO_SIZE(mem_ctx, aclint->naces * sizeof(struct security_ace));
         if (nt_ace_list==NULL)
         {
@@ -225 +284 @@
         for (aceint=aclint->first; aceint!=NULL; aceint=(SMB_ACE4_INT_T *)aceint->next) {
                 uint32_t mask;
-                DOM_SID sid;
+                struct dom_sid sid;
                 SMB_ACE4PROP_T  *ace = &aceint->prop;
-                uint32_t mapped_ace_flags;
+                uint32_t win_ace_flags;
 
                 DEBUG(10, ("magic: 0x%x, type: %d, iflags: %x, flags: %x, mask: %x, "
@@ -264 +323 @@
                 }
 
-                mapped_ace_flags = ace->aceFlags & 0xf;
-                if (!is_directory && (mapped_ace_flags & (SMB_ACE4_FILE_INHERIT_ACE|SMB_ACE4_DIRECTORY_INHERIT_ACE))) {
+                win_ace_flags = map_nfs4_ace_flags_to_windows_ace_flags(ace->aceFlags);
+                if (!is_directory && (win_ace_flags & (SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT))) {
                         /*
                          * GPFS sets inherits dir_inhert and file_inherit flags
@@ -272 +331 @@
                          */
                         DEBUG(10, ("removing inherit flags from nfs4 ace\n"));
-                        mapped_ace_flags &= ~(SMB_ACE4_FILE_INHERIT_ACE|SMB_ACE4_DIRECTORY_INHERIT_ACE);
-                }
-                DEBUG(10, ("mapped ace flags: 0x%x => 0x%x\n",
-                      ace->aceFlags, mapped_ace_flags));
-
-                mask = ace->aceMask;
+                        win_ace_flags &= ~(SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT);
+                }
+                DEBUG(10, ("Windows mapped ace flags: 0x%x => 0x%x\n",
+                      ace->aceFlags, win_ace_flags));
+
+                /* Windows clients expect SYNC on acls to
+                   correctly allow rename. See bug #7909. */
+                mask = ace->aceMask | SMB_ACE4_SYNCHRONIZE;
                 init_sec_ace(&nt_ace_list[good_aces++], &sid,
                         ace->aceType, mask,
-                        mapped_ace_flags);
+                        win_ace_flags);
         }
 
@@ -291 +352 @@
 static NTSTATUS smb_get_nt_acl_nfs4_common(const SMB_STRUCT_STAT *sbuf,
         uint32 security_info,
-        SEC_DESC **ppdesc, SMB4ACL_T *theacl)
+        struct security_descriptor **ppdesc, SMB4ACL_T *theacl)
 {
         int     good_aces = 0;
-        DOM_SID sid_owner, sid_group;
+        struct dom_sid sid_owner, sid_group;
         size_t sd_size = 0;
-        SEC_ACE *nt_ace_list = NULL;
-        SEC_ACL *psa = NULL;
+        struct security_ace *nt_ace_list = NULL;
+        struct security_acl *psa = NULL;
         TALLOC_CTX *mem_ctx = talloc_tos();
 
@@ -322 +383 @@
 
         DEBUG(10,("after make sec_acl\n"));
-        *ppdesc = make_sec_desc(mem_ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
-                                (security_info & OWNER_SECURITY_INFORMATION) ? &sid_owner : NULL,
-                                (security_info & GROUP_SECURITY_INFORMATION) ? &sid_group : NULL,
+        *ppdesc = make_sec_desc(mem_ctx, SD_REVISION, SEC_DESC_SELF_RELATIVE,
+                                (security_info & SECINFO_OWNER) ? &sid_owner : NULL,
+                                (security_info & SECINFO_GROUP) ? &sid_group : NULL,
                                 NULL, psa, &sd_size);
         if (*ppdesc==NULL) {
@@ -332 +393 @@
 
         DEBUG(10, ("smb_get_nt_acl_nfs4_common successfully exited with sd_size %d\n",
-                   (int)ndr_size_security_descriptor(*ppdesc, NULL, 0)));
+                   (int)ndr_size_security_descriptor(*ppdesc, 0)));
 
         return NT_STATUS_OK;
@@ -339 +400 @@
 NTSTATUS smb_fget_nt_acl_nfs4(files_struct *fsp,
                                uint32 security_info,
-                               SEC_DESC **ppdesc, SMB4ACL_T *theacl)
+                               struct security_descriptor **ppdesc, SMB4ACL_T *theacl)
 {
         SMB_STRUCT_STAT sbuf;
@@ -355 +416 @@
                               const char *name,
                               uint32 security_info,
-                              SEC_DESC **ppdesc, SMB4ACL_T *theacl)
+                              struct security_descriptor **ppdesc, SMB4ACL_T *theacl)
 {
         SMB_STRUCT_STAT sbuf;
@@ -456 +517 @@
                 if (ace->flags == aceNew->flags &&
                         ace->aceType==aceNew->aceType &&
-                        ((ace->aceFlags&SMB_ACE4_INHERIT_ONLY_ACE)==
-                         (aceNew->aceFlags&SMB_ACE4_INHERIT_ONLY_ACE)) &&
-                        (ace->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)==
-                        (aceNew->aceFlags&SMB_ACE4_IDENTIFIER_GROUP)
-                ) {
+                        ace->aceFlags==aceNew->aceFlags)
+                {
                         /* keep type safety; e.g. gid is an u.short */
                         if (ace->flags & SMB_ACE4_ID_SPECIAL)
@@ -482 +540 @@
 }
 
-static bool nfs4_map_sid(smbacl4_vfs_params *params, const DOM_SID *src,
-                         DOM_SID *dst)
+static bool nfs4_map_sid(smbacl4_vfs_params *params, const struct dom_sid *src,
+                         struct dom_sid *dst)
 {
         static struct db_context *mapping_db = NULL;
@@ -544 +602 @@
         uid_t ownerUID,
         gid_t ownerGID,
-        const SEC_ACE *ace_nt, /* input */
+        const struct security_ace *ace_nt, /* input */
         SMB_ACE4PROP_T *ace_v4 /* output */
 )
@@ -552 +610 @@
         memset(ace_v4, 0, sizeof(SMB_ACE4PROP_T));
         ace_v4->aceType = ace_nt->type; /* only ACCESS|DENY supported right now */
-        ace_v4->aceFlags = ace_nt->flags & SEC_ACE_FLAG_VALID_INHERIT;
+        ace_v4->aceFlags = map_windows_ace_flags_to_nfs4_ace_flags(ace_nt->flags);
         ace_v4->aceMask = ace_nt->access_mask &
-                (STD_RIGHT_ALL_ACCESS | SA_RIGHT_FILE_ALL_ACCESS);
+                (SEC_STD_ALL | SEC_FILE_ALL);
 
         se_map_generic(&ace_v4->aceMask, &file_generic_mapping);
@@ -566 +624 @@
                         ace_v4->aceMask, ace_nt->access_mask));
 
-        if (sid_equal(&ace_nt->trustee, &global_sid_World)) {
+        if (dom_sid_equal(&ace_nt->trustee, &global_sid_World)) {
                 ace_v4->who.special_id = SMB_ACE4_WHO_EVERYONE;
                 ace_v4->flags |= SMB_ACE4_ID_SPECIAL;
@@ -574 +632 @@
                 uid_t uid;
                 gid_t gid;
-                DOM_SID sid;
+                struct dom_sid sid;
                 
                 sid_copy(&sid, &ace_nt->trustee);
@@ -580 +638 @@
                 if (!lookup_sid(mem_ctx, &sid, &dom, &name, &type)) {
                         
-                        DOM_SID mapped;
+                        struct dom_sid mapped;
                         
                         if (!nfs4_map_sid(params, &sid, &mapped)) {
@@ -676 +734 @@
 static SMB4ACL_T *smbacl4_win2nfs4(
         const char *filename,
-        const SEC_ACL *dacl,
+        const struct security_acl *dacl,
         smbacl4_vfs_params *pparams,
         uid_t ownerUID,
@@ -720 +778 @@
 NTSTATUS smb_set_nt_acl_nfs4(files_struct *fsp,
         uint32 security_info_sent,
-        const SEC_DESC *psd,
+        const struct security_descriptor *psd,
         set_nfs4acl_native_fn_t set_nfs4_native)
 {
@@ -735 +793 @@
         DEBUG(10, ("smb_set_nt_acl_nfs4 invoked for %s\n", fsp_str_dbg(fsp)));
 
-        if ((security_info_sent & (DACL_SECURITY_INFORMATION |
-                GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION)) == 0)
+        if ((security_info_sent & (SECINFO_DACL |
+                SECINFO_GROUP | SECINFO_OWNER)) == 0)
         {
                 DEBUG(9, ("security_info_sent (0x%x) ignored\n",
@@ -752 +810 @@
         if (params.do_chown) {
                 /* chown logic is a copy/paste from posix_acl.c:set_nt_acl */
-                NTSTATUS status = unpack_nt_owners(SNUM(fsp->conn), &newUID, &newGID, security_info_sent, psd);
+                NTSTATUS status = unpack_nt_owners(fsp->conn, &newUID, &newGID, security_info_sent, psd);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(8, ("unpack_nt_owners failed"));
@@ -760 +818 @@
                     ((newGID != (gid_t)-1) && (sbuf.st_ex_gid != newGID))) {
 
-                        if(try_chown(fsp->conn, fsp->fsp_name, newUID,
-                                     newGID)) {
+                        status = try_chown(fsp, newUID, newGID);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 DEBUG(3,("chown %s, %u, %u failed. Error = "
                                          "%s.\n", fsp_str_dbg(fsp),
                                          (unsigned int)newUID,
                                          (unsigned int)newGID,
-                                         strerror(errno)));
-                                return map_nt_error_from_unix(errno);
+                                         nt_errstr(status)));
+                                return status;
                         }
 
@@ -785 +843 @@
         }
 
-        if (!(security_info_sent & DACL_SECURITY_INFORMATION) || psd->dacl ==NULL) {
+        if (!(security_info_sent & SECINFO_DACL) || psd->dacl ==NULL) {
                 DEBUG(10, ("no dacl found; security_info_sent = 0x%x\n", security_info_sent));
                 return NT_STATUS_OK;

trunk/server/source3/modules/nfs4_acls.h

@@ -77 +77 @@
 #define SMB_ACE4_FAILED_ACCESS_ACE_FLAG       0x00000020
 #define SMB_ACE4_IDENTIFIER_GROUP             0x00000040
+#define SMB_ACE4_INHERITED_ACE                0x00000080
 #define SMB_ACE4_ALL_FLAGS      ( SMB_ACE4_FILE_INHERIT_ACE | SMB_ACE4_DIRECTORY_INHERIT_ACE \
 | SMB_ACE4_NO_PROPAGATE_INHERIT_ACE | SMB_ACE4_INHERIT_ONLY_ACE | SMB_ACE4_SUCCESSFUL_ACCESS_ACE_FLAG \
-| SMB_ACE4_FAILED_ACCESS_ACE_FLAG | SMB_ACE4_IDENTIFIER_GROUP )
+| SMB_ACE4_FAILED_ACCESS_ACE_FLAG | SMB_ACE4_IDENTIFIER_GROUP | SMB_ACE4_INHERITED_ACE)
 
         uint32  aceMask;        /* Access rights */
@@ -132 +133 @@
 NTSTATUS smb_fget_nt_acl_nfs4(files_struct *fsp,
         uint32 security_info,
-        SEC_DESC **ppdesc, SMB4ACL_T *theacl);
+        struct security_descriptor **ppdesc, SMB4ACL_T *theacl);
 
 NTSTATUS smb_get_nt_acl_nfs4(connection_struct *conn,
         const char *name,
         uint32 security_info,
-        SEC_DESC **ppdesc, SMB4ACL_T *theacl);
+        struct security_descriptor **ppdesc, SMB4ACL_T *theacl);
 
 /* Callback function needed to set the native acl
@@ -145 +146 @@
 NTSTATUS smb_set_nt_acl_nfs4(files_struct *fsp,
         uint32 security_info_sent,
-        const SEC_DESC *psd,
+        const struct security_descriptor *psd,
         set_nfs4acl_native_fn_t set_nfs4_native);
 

trunk/server/source3/modules/onefs.h

@@ -121 +121 @@
 
 NTSTATUS onefs_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
-                           uint32 security_info, SEC_DESC **ppdesc);
+                           uint32 security_info, struct security_descriptor **ppdesc);
 
 NTSTATUS onefs_get_nt_acl(vfs_handle_struct *handle, const char* name,
-                          uint32 security_info, SEC_DESC **ppdesc);
+                          uint32 security_info, struct security_descriptor **ppdesc);
 
 NTSTATUS onefs_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
-                           uint32 security_info_sent, const SEC_DESC *psd);
+                           uint32 security_info_sent,
+                           const struct security_descriptor *psd);
 
 /*
@@ -133 +134 @@
  */
 struct ifs_security_descriptor;
-NTSTATUS onefs_samba_sd_to_sd(uint32_t security_info_sent, const SEC_DESC *psd,
+NTSTATUS onefs_samba_sd_to_sd(uint32_t security_info_sent,
+                              const struct security_descriptor *psd,
                               struct ifs_security_descriptor *sd, int snum,
                               uint32_t *security_info_effective);
-
-NTSTATUS onefs_split_ntfs_stream_name(TALLOC_CTX *mem_ctx, const char *fname,
-                                      char **pbase, char **pstream);
 
 NTSTATUS onefs_stream_prep_smb_fname(TALLOC_CTX *ctx,

trunk/server/source3/modules/onefs_acl.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"
@@ -39 +40 @@
  */
 static bool
-onefs_sid_to_identity(const DOM_SID *sid, struct ifs_identity *id,
+onefs_sid_to_identity(const struct dom_sid *sid, struct ifs_identity *id,
     bool is_group)
 {
@@ -81 +82 @@
  */
 static bool
-onefs_identity_to_sid(struct ifs_identity *id, DOM_SID *sid)
+onefs_identity_to_sid(struct ifs_identity *id, struct dom_sid *sid)
 {
         if (!id || !sid)
@@ -117 +118 @@
 
 static bool
-onefs_og_to_identity(DOM_SID *sid, struct ifs_identity * ident,
+onefs_og_to_identity(struct dom_sid *sid, struct ifs_identity * ident,
     bool is_group, int snum)
 {
-        const DOM_SID *b_admin_sid = &global_sid_Builtin_Administrators;
+        const struct dom_sid *b_admin_sid = &global_sid_Builtin_Administrators;
 
         if (!onefs_sid_to_identity(sid, ident, is_group)) {
@@ -141 +142 @@
 
 static bool
-sid_in_ignore_list(DOM_SID * sid, int snum)
+sid_in_ignore_list(struct dom_sid * sid, int snum)
 {
         const char ** sid_list = NULL;
-        DOM_SID match;
+        struct dom_sid match;
 
         sid_list = lp_parm_string_list(snum, PARM_ONEFS_TYPE,
@@ -168 +169 @@
  */
 static bool
-onefs_samba_ace_to_ace(SEC_ACE * samba_ace, struct ifs_ace * ace,
+onefs_samba_ace_to_ace(struct security_ace * samba_ace, struct ifs_ace * ace,
     bool *mapped, int snum)
 {
@@ -233 +234 @@
 
 /**
- * Convert a SEC_ACL to a struct ifs_security_acl
+ * Convert a struct security_acl to a struct ifs_security_acl
  */
 static bool
-onefs_samba_acl_to_acl(SEC_ACL *samba_acl, struct ifs_security_acl **acl,
+onefs_samba_acl_to_acl(struct security_acl *samba_acl, struct ifs_security_acl **acl,
     bool * ignore_aces, int snum)
 {
         int num_aces = 0;
         struct ifs_ace *aces = NULL;
-        SEC_ACE *samba_aces;
+        struct security_ace *samba_aces;
         bool mapped;
         int i, j;
@@ -288 +289 @@
 
 /**
- * Convert a struct ifs_security_acl to a SEC_ACL
+ * Convert a struct ifs_security_acl to a struct security_acl
  */
 static bool
-onefs_acl_to_samba_acl(struct ifs_security_acl *acl, SEC_ACL **samba_acl)
-{
-        SEC_ACE *samba_aces = NULL;
-        SEC_ACL *tmp_samba_acl = NULL;
+onefs_acl_to_samba_acl(struct ifs_security_acl *acl, struct security_acl **samba_acl)
+{
+        struct security_ace *samba_aces = NULL;
+        struct security_acl *tmp_samba_acl = NULL;
         int i, num_aces = 0;
 
@@ -314 +315 @@
         /* Allocate the ace list. */
         if (num_aces > 0) {
-                if ((samba_aces = SMB_MALLOC_ARRAY(SEC_ACE, num_aces)) == NULL)
+                if ((samba_aces = SMB_MALLOC_ARRAY(struct security_ace, num_aces)) == NULL)
                 {
                         DEBUG(0, ("Unable to malloc space for %d aces.\n",
@@ -320 +321 @@
                         return false;
                 }
-                memset(samba_aces, '\0', (num_aces) * sizeof(SEC_ACE));
+                memset(samba_aces, '\0', (num_aces) * sizeof(struct security_ace));
         }
 
         for (i = 0; i < num_aces; i++) {
-                DOM_SID sid;
+                struct dom_sid sid;
 
                 if (!onefs_identity_to_sid(&acl->aces[i].trustee, &sid))
@@ -554 +555 @@
                 /* Use existing samba logic to derive the mode bits. */
                 file_mode = unix_mode(fsp->conn, 0, fsp->fsp_name, NULL);
-                dir_mode = unix_mode(fsp->conn, aDIR, fsp->fsp_name, NULL);
+                dir_mode = unix_mode(fsp->conn, FILE_ATTRIBUTE_DIRECTORY, fsp->fsp_name, NULL);
 
                 /* Initialize ACEs. */
@@ -605 +606 @@
 NTSTATUS
 onefs_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
-                  uint32 security_info, SEC_DESC **ppdesc)
+                  uint32 security_info, struct security_descriptor **ppdesc)
 {
         int error;
@@ -611 +612 @@
         size_t size = 0;
         struct ifs_security_descriptor *sd = NULL;
-        DOM_SID owner_sid, group_sid;
-        DOM_SID *ownerp, *groupp;
-        SEC_ACL *dacl, *sacl;
-        SEC_DESC *pdesc;
+        struct dom_sid owner_sid, group_sid;
+        struct dom_sid *ownerp, *groupp;
+        struct security_acl *dacl, *sacl;
+        struct security_descriptor *pdesc;
         bool alloced = false;
         bool new_aces_alloced = false;
@@ -630 +631 @@
                 PARM_IGNORE_SACLS, PARM_IGNORE_SACLS_DEFAULT)) {
                 DEBUG(5, ("Ignoring SACL on %s.\n", fsp_str_dbg(fsp)));
-                security_info &= ~SACL_SECURITY_INFORMATION;
+                security_info &= ~SECINFO_SACL;
         }
 
@@ -706 +707 @@
 
         /* Copy owner into ppdesc */
-        if (security_info & OWNER_SECURITY_INFORMATION) {
+        if (security_info & SECINFO_OWNER) {
                 if (!onefs_identity_to_sid(sd->owner, &owner_sid)) {
                         status = NT_STATUS_INVALID_PARAMETER;
@@ -716 +717 @@
 
         /* Copy group into ppdesc */
-        if (security_info & GROUP_SECURITY_INFORMATION) {
+        if (security_info & SECINFO_GROUP) {
                 if (!onefs_identity_to_sid(sd->group, &group_sid)) {
                         status = NT_STATUS_INVALID_PARAMETER;
@@ -726 +727 @@
 
         /* Copy DACL into ppdesc */
-        if (security_info & DACL_SECURITY_INFORMATION) {
+        if (security_info & SECINFO_DACL) {
                 if (!onefs_acl_to_samba_acl(sd->dacl, &dacl)) {
                         status = NT_STATUS_INVALID_PARAMETER;
@@ -734 +735 @@
 
         /* Copy SACL into ppdesc */
-        if (security_info & SACL_SECURITY_INFORMATION) {
+        if (security_info & SECINFO_SACL) {
                 if (!onefs_acl_to_samba_acl(sd->sacl, &sacl)) {
                         status = NT_STATUS_INVALID_PARAMETER;
@@ -791 +792 @@
 NTSTATUS
 onefs_get_nt_acl(vfs_handle_struct *handle, const char* name,
-                 uint32 security_info, SEC_DESC **ppdesc)
+                 uint32 security_info, struct security_descriptor **ppdesc)
 {
         files_struct finfo;
@@ -818 +819 @@
 /**
  * Isilon-specific function for setting up an ifs_security_descriptor, given a
- * samba SEC_DESC.
+ * samba struct security_descriptor
  *
  * @param[out] sd ifs_security_descriptor to fill in
@@ -824 +825 @@
  * @return NTSTATUS_OK if successful
  */
-NTSTATUS onefs_samba_sd_to_sd(uint32_t security_info_sent, const SEC_DESC *psd,
+NTSTATUS onefs_samba_sd_to_sd(uint32_t security_info_sent,
+                              const struct security_descriptor *psd,
                               struct ifs_security_descriptor *sd, int snum,
                               uint32_t *security_info_effective)
@@ -840 +842 @@
 
         /* Setup owner */
-        if (security_info_sent & OWNER_SECURITY_INFORMATION) {
+        if (security_info_sent & SECINFO_OWNER) {
                 if (!onefs_og_to_identity(psd->owner_sid, &owner, false, snum))
                         return NT_STATUS_ACCESS_DENIED;
@@ -850 +852 @@
 
         /* Setup group */
-        if (security_info_sent & GROUP_SECURITY_INFORMATION) {
+        if (security_info_sent & SECINFO_GROUP) {
                 if (!onefs_og_to_identity(psd->group_sid, &group, true, snum))
                         return NT_STATUS_ACCESS_DENIED;
@@ -860 +862 @@
 
         /* Setup DACL */
-        if ((security_info_sent & DACL_SECURITY_INFORMATION) && (psd->dacl)) {
+        if ((security_info_sent & SECINFO_DACL) && (psd->dacl)) {
                 if (!onefs_samba_acl_to_acl(psd->dacl, &daclp, &ignore_aces,
                         snum))
@@ -866 +868 @@
 
                 if (ignore_aces == true)
-                        *security_info_effective &= ~DACL_SECURITY_INFORMATION;
+                        *security_info_effective &= ~SECINFO_DACL;
         }
 
         /* Setup SACL */
-        if (security_info_sent & SACL_SECURITY_INFORMATION) {
+        if (security_info_sent & SECINFO_SACL) {
 
                 if (lp_parm_bool(snum, PARM_ONEFS_TYPE,
                             PARM_IGNORE_SACLS, PARM_IGNORE_SACLS_DEFAULT)) {
                         DEBUG(5, ("Ignoring SACL.\n"));
-                        *security_info_effective &= ~SACL_SECURITY_INFORMATION;
+                        *security_info_effective &= ~SECINFO_SACL;
                 } else {
                         if (psd->sacl) {
@@ -884 +886 @@
                                 if (ignore_aces == true) {
                                         *security_info_effective &=
-                                            ~SACL_SECURITY_INFORMATION;
+                                            ~SECINFO_SACL;
                                 }
                         }
@@ -910 +912 @@
 NTSTATUS
 onefs_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
-                  uint32_t sec_info_sent, const SEC_DESC *psd)
+                  uint32_t sec_info_sent, const struct security_descriptor *psd)
 {
         struct ifs_security_descriptor sd = {};

trunk/server/source3/modules/onefs_cbrl.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 
@@ -28 +29 @@
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
-
-extern struct blocking_lock_record *blocking_lock_queue;
 
 static uint64_t onefs_get_new_id(void) {
@@ -85 +84 @@
 static void onefs_cbrl_enumerate_blq(const char *fn)
 {
+        struct smbd_server_connection *sconn = smbd_server_conn;
         struct blocking_lock_record *blr;
 
@@ -92 +92 @@
         DEBUG(10, ("CBRL BLR records (%s):\n", fn));
 
-        for (blr = blocking_lock_queue; blr; blr = blr->next)
-                DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr)));
+        if (sconn->using_smb2) {
+                struct smbd_smb2_request *smb2req;
+                for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
+                        blr = get_pending_smb2req_blr(smb2req);
+                        if (blr) {
+                                DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr)));
+                        }
+                }
+        } else {
+                for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next)
+                        DEBUGADD(10, ("%s\n", onefs_cbrl_blr_state_str(blr)));
+        }
 }
 
 static struct blocking_lock_record *onefs_cbrl_find_blr(uint64_t id)
 {
+        struct smbd_server_connection *sconn = smbd_server_conn;
         struct blocking_lock_record *blr;
         struct onefs_cbrl_blr_state *bs;
@@ -103 +114 @@
         onefs_cbrl_enumerate_blq("onefs_cbrl_find_blr");
 
-        for (blr = blocking_lock_queue; blr; blr = blr->next) {
-                bs = (struct onefs_cbrl_blr_state *)blr->blr_private;
-
-                /* We don't control all of the BLRs on the BLQ. */
-                if (bs == NULL)
-                        continue;
-
-                if (bs->id == id) {
-                        DEBUG(10, ("found %s\n",
-                            onefs_cbrl_blr_state_str(blr)));
-                        break;
+        if (sconn->using_smb2) {
+                struct smbd_smb2_request *smb2req;
+                for (smb2req = sconn->smb2.requests; smb2req; smb2req = nextreq) {
+                        blr = get_pending_smb2req_blr(smb2req);
+                        if (!blr) {
+                                continue;
+                        }
+                        bs = (struct onefs_cbrl_blr_state *)blr->blr_private;
+                        if (bs == NULL) {
+                                continue;
+                        }
+                        if (bs->id == id) {
+                                DEBUG(10, ("found %s\n",
+                                    onefs_cbrl_blr_state_str(blr)));
+                                break;
+                        }
+                }
+        } else {
+                for (blr = sconn->smb1.locks.blocking_lock_queue; blr; blr = blr->next) {
+                        bs = (struct onefs_cbrl_blr_state *)blr->blr_private;
+
+                        /* We don't control all of the BLRs on the BLQ. */
+                        if (bs == NULL)
+                                continue;
+
+                        if (bs->id == id) {
+                                DEBUG(10, ("found %s\n",
+                                    onefs_cbrl_blr_state_str(blr)));
+                                break;
+                        }
                 }
         }
@@ -157 +187 @@
 
         /* Process the queue, to try the next lock or finish up. */
-        process_blocking_lock_queue();
+        process_blocking_lock_queue(smbd_server_conn);
 }
 
@@ -180 +210 @@
         /* Process the queue. It will end up trying to retake the same lock,
          * see the error in onefs_cbrl_lock_windows() and fail. */
-        process_blocking_lock_queue();
+        process_blocking_lock_queue(smbd_server_conn);
 }
 

trunk/server/source3/modules/onefs_config.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs_config.h"
 

trunk/server/source3/modules/onefs_dir.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"

trunk/server/source3/modules/onefs_notify.c

@@ -35 +35 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 

trunk/server/source3/modules/onefs_open.c

@@ -34 +34 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"
@@ -55 +56 @@
                               uint32_t oplock_request,
                               uint64_t allocation_size,
+                              uint32_t private_flags,
                               struct security_descriptor *sd,
                               struct ea_list *ea_list,
@@ -313 +315 @@
                         True : False;
         }
-        fsp->print_file = False;
+        fsp->print_file = NULL;
         fsp->modified = False;
         fsp->sent_oplock_break = NO_BREAK_SENT;
@@ -326 +328 @@
 
         DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
-                 conn->server_info->unix_name,
+                 conn->session_info->unix_name,
                  smb_fname_str_dbg(smb_fname),
                  BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
@@ -358 +360 @@
                 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
                         DEBUG(0, ("Trying to defer an already deferred "
-                                  "request: mid=%d, exiting\n", req->mid));
+                                "request: mid=%llu, exiting\n",
+                                (unsigned long long)req->mid));
                         exit_server("attempt to defer a deferred request");
                 }
@@ -366 +369 @@
 
         DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
-                  "open entry for mid %u\n",
+                  "open entry for mid %llu\n",
                   (unsigned int)request_time.tv_sec,
                   (unsigned int)request_time.tv_usec,
-                  (unsigned int)req->mid));
-
-        if (!push_deferred_smb_message(req, request_time, timeout,
-                                       (char *)state, sizeof(*state))) {
-                exit_server("push_deferred_smb_message failed");
+                  (unsigned long long)req->mid));
+
+        if (!push_deferred_open_message_smb(req, request_time, timeout,
+                                       state->id, (char *)state, sizeof(*state))) {
+                exit_server("push_deferred_open_message_smb failed");
         }
         add_deferred_open(lck, req->mid, request_time, state->id);
@@ -439 +442 @@
                                   uint32 new_dos_attributes,
                                   int oplock_request,
+                                  uint32_t private_flags,
                                   struct security_descriptor *sd,
                                   files_struct *fsp,
@@ -456 +460 @@
         int info;
         uint32 existing_dos_attributes = 0;
-        struct pending_message_list *pml = NULL;
         struct timeval request_time = timeval_zero();
         struct share_mode_lock *lck = NULL;
@@ -482 +485 @@
                            smb_fname_str_dbg(smb_fname)));
 
-                return print_fsp_open(req, conn, smb_fname->base_name,
-                                      req->vuid, fsp);
+                return print_spool_open(fsp, smb_fname->base_name,
+                                        req->vuid);
         }
 
@@ -496 +499 @@
                 new_dos_attributes = 0;
         } else {
-                /* We add aARCH to this as this mode is only used if the file is
+                /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
                  * created new. */
-                unx_mode = unix_mode(conn, new_dos_attributes | aARCH,
+                unx_mode = unix_mode(conn, new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
                                      smb_fname, parent_dir);
         }
@@ -541 +544 @@
          */
 
-        if ((req != NULL)
-            && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
-                struct deferred_open_record *state =
-                        (struct deferred_open_record *)pml->private_data.data;
-
-                /* Remember the absolute time of the original
-                   request with this mid. We'll use it later to
-                   see if this has timed out. */
-
-                request_time = pml->request_time;
-
-                /* Remove the deferred open entry under lock. */
-                lck = get_share_mode_lock(talloc_tos(), state->id, NULL, NULL,
-                                          NULL);
-                if (lck == NULL) {
-                        DEBUG(0, ("could not get share mode lock\n"));
-                } else {
-                        del_deferred_open_entry(lck, req->mid);
-                        TALLOC_FREE(lck);
-                }
-
-                /* Ensure we don't reprocess this message. */
-                remove_deferred_open_smb_message(req->mid);
-
-                /*
-                 * When receiving a semlock_async_failure message, the
-                 * deferred open will be marked as "failed". Returning
-                 * INTERNAL_ERROR.
-                 */
-                if (state->failed) {
-                        DEBUG(0, ("onefs_open_file_ntcreate: "
-                                  "semlock_async_failure detected!\n"));
-                        return NT_STATUS_INTERNAL_ERROR;
+        if (req) {
+                void *ptr;
+                if (get_deferred_open_message_state(req,
+                                &request_time,
+                                &ptr)) {
+                        struct deferred_open_record *state = (struct deferred_open_record *)ptr;
+
+                        /* Remember the absolute time of the original
+                           request with this mid. We'll use it later to
+                           see if this has timed out. */
+
+                        /* Remove the deferred open entry under lock. */
+                        remove_deferred_open_entry(state->id, req->mid);
+
+                        /* Ensure we don't reprocess this message. */
+                        remove_deferred_open_message_smb(req->mid);
+
+                        /*
+                         * When receiving a semlock_async_failure message, the
+                         * deferred open will be marked as "failed". Returning
+                         * INTERNAL_ERROR.
+                         */
+                        if (state->failed) {
+                                DEBUG(0, ("onefs_open_file_ntcreate: "
+                                          "semlock_async_failure detected!\n"));
+                                return NT_STATUS_INTERNAL_ERROR;
+                        }
                 }
         }
@@ -591 +588 @@
         /* Setup dos_attributes to be set by ifs_createfile */
         if (lp_store_dos_attributes(SNUM(conn))) {
-                createfile_attributes = (new_dos_attributes | aARCH) &
+                createfile_attributes = (new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE) &
                     ~(FILE_ATTRIBUTE_NONINDEXED | FILE_ATTRIBUTE_COMPRESSED);
         }
 
         /* Ignore oplock requests if oplocks are disabled. */
-        if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
+        if (!lp_oplocks(SNUM(conn)) ||
             IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
                 /* Mask off everything except the private Samba bits. */
@@ -819 +816 @@
 
         fsp->share_access = share_access;
-        fsp->fh->private_options = create_options;
+        fsp->fh->private_options = private_flags;
         fsp->access_mask = open_access_mask; /* We change this to the
                                               * requested access_mask after
@@ -993 +990 @@
 
                         /* Try to find dup fsp if possible. */
-                        if (create_options &
+                        if (private_flags &
                             (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
                              NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
@@ -1262 +1259 @@
          */
 
-        /* Record the options we were opened with. */
-        fsp->share_access = share_access;
-        fsp->fh->private_options = create_options;
         /*
          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
@@ -1317 +1311 @@
         }
 
-        set_share_mode(lck, fsp, conn->server_info->utok.uid, 0,
+        set_share_mode(lck, fsp, get_current_uid(conn),
+                        req ? req->mid : 0,
                        fsp->oplock_type);
 
@@ -1489 +1484 @@
                 file_attributes = 0;
         } else {
-                mode = unix_mode(conn, aDIR, smb_dname, parent_dir);
+                mode = unix_mode(conn, FILE_ATTRIBUTE_DIRECTORY, smb_dname, parent_dir);
         }
 
@@ -1630 +1625 @@
 
         fsp->share_access = share_access;
-        fsp->fh->private_options = create_options;
+        fsp->fh->private_options = 0;
         /*
          * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
          */
         fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
-        fsp->print_file = False;
+        fsp->print_file = NULL;
         fsp->modified = False;
         fsp->oplock_type = NO_OPLOCK;
@@ -1673 +1668 @@
         }
 
-        set_share_mode(lck, fsp, conn->server_info->utok.uid, 0, NO_OPLOCK);
+        set_share_mode(lck, fsp, get_current_uid(conn),
+                req ? req->mid : 0, NO_OPLOCK);
 
         /*
@@ -1719 +1715 @@
                                            uint32_t oplock_request,
                                            uint64_t allocation_size,
+                                           uint32_t private_flags,
                                            struct security_descriptor *sd,
                                            struct ea_list *ea_list,
@@ -1733 +1730 @@
                   "file_attributes = 0x%x, share_access = 0x%x, "
                   "create_disposition = 0x%x create_options = 0x%x "
-                  "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
+                  "oplock_request = 0x%x private_flags = 0x%x "
+                  "ea_list = 0x%p, sd = 0x%p, "
                   "fname = %s\n",
                   (unsigned int)access_mask,
@@ -1741 +1739 @@
                   (unsigned int)create_options,
                   (unsigned int)oplock_request,
+                  (unsigned int)private_flags,
                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
 
@@ -1824 +1823 @@
                         NO_OPLOCK,                      /* oplock_request */
                         0,                              /* allocation_size */
+                        0,                              /* private_flags */
                         NULL,                           /* sd */
                         NULL,                           /* ea_list */
@@ -2067 +2067 @@
                            uint32_t oplock_request,
                            uint64_t allocation_size,
+                           uint32_t private_flags,
                            struct security_descriptor *sd,
                            struct ea_list *ea_list,
@@ -2081 +2082 @@
                   "file_attributes = 0x%x, share_access = 0x%x, "
                   "create_disposition = 0x%x create_options = 0x%x "
-                  "oplock_request = 0x%x "
+                  "oplock_request = 0x%x private_flags = 0x%x"
                   "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
                   "fname = %s\n",
@@ -2090 +2091 @@
                   (unsigned int)create_options,
                   (unsigned int)oplock_request,
+                  (unsigned int)private_flags,
                   (unsigned int)root_dir_fid,
                   ea_list, sd, smb_fname_str_dbg(smb_fname)));
@@ -2108 +2110 @@
         if (!NT_STATUS_IS_OK(status)) {
                 goto fail;
+        }
+
+        if (is_ntfs_stream_smb_fname(smb_fname)) {
+                if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
+                        status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                        goto fail;
+                }
+
+                if (is_ntfs_default_stream_smb_fname(smb_fname)) {
+                        int ret;
+                        smb_fname->stream_name = NULL;
+                        /* We have to handle this error here. */
+                        if (create_options & FILE_DIRECTORY_FILE) {
+                                status = NT_STATUS_NOT_A_DIRECTORY;
+                                goto fail;
+                        }
+                        if (lp_posix_pathnames()) {
+                                ret = SMB_VFS_LSTAT(conn, smb_fname);
+                        } else {
+                                ret = SMB_VFS_STAT(conn, smb_fname);
+                        }
+
+                        if (ret == 0 && VALID_STAT_OF_DIR(smb_fname->st)) {
+                                status = NT_STATUS_FILE_IS_A_DIRECTORY;
+                                goto fail;
+                        }
+                }
         }
 
@@ -2121 +2150 @@
                 oplock_request,                         /* oplock_request */
                 allocation_size,                        /* allocation_size */
+                private_flags,
                 sd,                                     /* sd */
                 ea_list,                                /* ea_list */

trunk/server/source3/modules/onefs_shadow_copy.c

@@ -22 +22 @@
  */
 
+#include "smbd/smbd.h"
 #include <ifs/ifs_syscalls.h>
 #include <sys/types.h>

trunk/server/source3/modules/onefs_streams.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"

trunk/server/source3/modules/onefs_system.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"
@@ -270 +271 @@
                         ret = sendfile(fromfd, tofd, offset, total, &hdr,
                                        &nwritten, flags);
-                } while (ret == -1 && errno == EINTR);
+#if defined(EWOULDBLOCK)
+                } while (ret == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
+#else
+                } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
+#endif
 
                 /* On error we're done. */

trunk/server/source3/modules/perfcount_onefs.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include <sys/isi_stats_protocol.h>
 #include <sys/isi_stats_client.h>
@@ -303 +304 @@
         /* get address info once, doesn't change for process */
         if (rem_addr == 0) {
-                struct sockaddr_storage sa;
-                socklen_t sa_len;
-                int fd = smbd_server_fd();
-
-                sa_len = sizeof sa;
-                if (getpeername(fd, (struct sockaddr *)&sa, &sa_len) == 0 && 
-                    sa.ss_family == AF_INET)
-                        rem_addr = ((struct sockaddr_in *)&sa)->sin_addr.s_addr;
-                else
+
+#error Isilon, please remove this after testing the code below
+
+                char *addr;
+
+                addr = talloc_sub_basic(talloc_tos(), "", "", "%I");
+                if (addr != NULL) {
+                        rem_addr = interpret_addr(addr);
+                        TALLOC_FREE(addr);
+                } else {
                         rem_addr = ISC_MASKED_ADDR;
-
-                sa_len = sizeof sa;
-                if (getsockname(fd, (struct sockaddr *)&sa, &sa_len) == 0 &&
-                    sa.ss_family == AF_INET)
-                        loc_addr = ((struct sockaddr_in *)&sa)->sin_addr.s_addr;
-                else
+                }
+
+                addr = talloc_sub_basic(talloc_tos(), "", "", "%i");
+                if (addr != NULL) {
+                        loc_addr = interpret_addr(addr);
+                        TALLOC_FREE(addr);
+                } else {
                         loc_addr = ISC_MASKED_ADDR;
+                }
         }
 
@@ -336 +340 @@
                         tmp->iod.in_bytes, tmp->iod.out_bytes));
 #endif
-                SAFE_FREE(tmp->prev);
+                SAFE_FREE(DLIST_PREV(tmp));
         }
 

trunk/server/source3/modules/perfcount_test.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 #define PARM_PC_TEST_TYPE               "pc_test"
@@ -177 +178 @@
         DEBUG(0,("#####  Dumping Performance Counters #####\n"));
 
-        for (i=0; i < 256; i++) {
-               for (head = g_list[i]; head != NULL; head = head->next) {
-                       perfcount_test_dump_counter(head, 0);
-                       head->prev = NULL;
-                       SAFE_FREE(head->prev);
-               }
-               SAFE_FREE(head);
+        for (i=0; i < MAX_OP; i++) {
+                struct perfcount_test_counter *next;
+                for (head = g_list[i]; head != NULL; head = next) {
+                        next = head->next;
+                        perfcount_test_dump_counter(head, 0);
+                        SAFE_FREE(head);
+                }
+                g_list[i] = NULL;
         }
 }

trunk/server/source3/modules/vfs_acl_common.c

@@ -20 +20 @@
  */
 
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "../libcli/security/security.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+
 static NTSTATUS create_acl_blob(const struct security_descriptor *psd,
                         DATA_BLOB *pblob,
@@ -35 +40 @@
                         DATA_BLOB *pblob);
 
-#define HASH_SECURITY_INFO (OWNER_SECURITY_INFORMATION | \
-                                GROUP_SECURITY_INFORMATION | \
-                                DACL_SECURITY_INFORMATION | \
-                                SACL_SECURITY_INFORMATION)
+#define HASH_SECURITY_INFO (SECINFO_OWNER | \
+                                SECINFO_GROUP | \
+                                SECINFO_DACL | \
+                                SECINFO_SACL)
 
 /*******************************************************************
@@ -78 +83 @@
         size_t sd_size;
 
-        ndr_err = ndr_pull_struct_blob(pblob, ctx, NULL, &xacl,
+        ndr_err = ndr_pull_struct_blob(pblob, ctx, &xacl,
                         (ndr_pull_flags_fn_t)ndr_pull_xattr_NTACL);
 
@@ -84 +89 @@
                 DEBUG(5, ("parse_acl_blob: ndr_pull_xattr_NTACL failed: %s\n",
                         ndr_errstr(ndr_err)));
-                return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
         }
 
         switch (xacl.version) {
                 case 2:
-                        *ppdesc = make_sec_desc(ctx, SEC_DESC_REVISION,
+                        *ppdesc = make_sec_desc(ctx, SD_REVISION,
                                         xacl.info.sd_hs2->sd->type | SEC_DESC_SELF_RELATIVE,
                                         xacl.info.sd_hs2->sd->owner_sid,
@@ -101 +106 @@
                         break;
                 case 3:
-                        *ppdesc = make_sec_desc(ctx, SEC_DESC_REVISION,
+                        *ppdesc = make_sec_desc(ctx, SD_REVISION,
                                         xacl.info.sd_hs3->sd->type | SEC_DESC_SELF_RELATIVE,
                                         xacl.info.sd_hs3->sd->owner_sid,
@@ -145 +150 @@
 
         ndr_err = ndr_push_struct_blob(
-                        pblob, ctx, NULL, &xacl,
+                        pblob, ctx, &xacl,
                         (ndr_push_flags_fn_t)ndr_push_xattr_NTACL);
 
@@ -151 +156 @@
                 DEBUG(5, ("create_acl_blob: ndr_push_xattr_NTACL failed: %s\n",
                         ndr_errstr(ndr_err)));
-                return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
         }
 
@@ -250 +255 @@
         DATA_BLOB blob;
         NTSTATUS status;
-        uint16_t hash_type;
+        uint16_t hash_type = XATTR_SD_HASH_TYPE_NONE;
         uint8_t hash[XATTR_SD_HASH_SIZE];
         uint8_t hash_tmp[XATTR_SD_HASH_SIZE];
@@ -402 +407 @@
         }
 
-        if (!(security_info & OWNER_SECURITY_INFORMATION)) {
+        if (!(security_info & SECINFO_OWNER)) {
                 psd->owner_sid = NULL;
         }
-        if (!(security_info & GROUP_SECURITY_INFORMATION)) {
+        if (!(security_info & SECINFO_GROUP)) {
                 psd->group_sid = NULL;
         }
-        if (!(security_info & DACL_SECURITY_INFORMATION)) {
+        if (!(security_info & SECINFO_DACL)) {
                 psd->dacl = NULL;
         }
-        if (!(security_info & SACL_SECURITY_INFORMATION)) {
+        if (!(security_info & SECINFO_SACL)) {
                 psd->sacl = NULL;
         }
@@ -444 +449 @@
         struct dom_sid *owner_sid = NULL;
         struct dom_sid *group_sid = NULL;
-        uint32_t security_info_sent = (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION);
-        size_t size;
+        uint32_t security_info_sent = (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL);
         bool inherit_owner = lp_inherit_owner(SNUM(handle->conn));
         bool inheritable_components = sd_has_inheritable_components(parent_desc,
                                         is_directory);
+        size_t size;
 
         if (!inheritable_components && !inherit_owner) {
@@ -470 +475 @@
 
         if (owner_sid == NULL) {
-                owner_sid = &handle->conn->server_info->ptok->user_sids[PRIMARY_USER_SID_INDEX];
+                owner_sid = &handle->conn->session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
         }
         if (group_sid == NULL) {
-                group_sid = &handle->conn->server_info->ptok->user_sids[PRIMARY_GROUP_SID_INDEX];
+                group_sid = &handle->conn->session_info->security_token->sids[PRIMARY_GROUP_SID_INDEX];
         }
 
@@ -566 +571 @@
         status = smb1_file_se_access_check(handle->conn,
                                         parent_desc,
-                                        handle->conn->server_info->ptok,
+                                        get_current_nttok(handle->conn),
                                         access_mask,
                                         &access_granted);
@@ -614 +619 @@
                                 NULL,
                                 fname,
-                                (OWNER_SECURITY_INFORMATION |
-                                 GROUP_SECURITY_INFORMATION |
-                                 DACL_SECURITY_INFORMATION),
+                                (SECINFO_OWNER |
+                                 SECINFO_GROUP |
+                                 SECINFO_DACL),
                                 &pdesc);
         if (NT_STATUS_IS_OK(status)) {
@@ -622 +627 @@
                 status = smb1_file_se_access_check(handle->conn,
                                         pdesc,
-                                        handle->conn->server_info->ptok,
+                                        get_current_nttok(handle->conn),
                                         fsp->access_mask,
                                         &access_granted);
@@ -837 +842 @@
                 parent_dir, final_component ));
 
-        /* cd into the parent dir to pin it. */
+        /* cd into the parent dir to pin it. */
         ret = SMB_VFS_CHDIR(conn, parent_dir);
         if (ret == -1) {
@@ -856 +861 @@
         /* Ensure we have this file open with DELETE access. */
         id = vfs_file_id_from_sbuf(conn, &local_fname.st);
-        for (fsp = file_find_di_first(id); fsp; file_find_di_next(fsp)) {
+        for (fsp = file_find_di_first(conn->sconn, id); fsp;
+             file_find_di_next(fsp)) {
                 if (fsp->access_mask & DELETE_ACCESS &&
                                 fsp->delete_on_close) {
@@ -927 +933 @@
                                 uint32_t oplock_request,
                                 uint64_t allocation_size,
+                                uint32_t private_flags,
                                 struct security_descriptor *sd,
                                 struct ea_list *ea_list,
@@ -949 +956 @@
                                         oplock_request,
                                         allocation_size,
+                                        private_flags,
                                         sd,
                                         ea_list,

trunk/server/source3/modules/vfs_acl_tdb.c

@@ -22 +22 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
 #include "librpc/gen_ndr/xattr.h"
 #include "librpc/gen_ndr/ndr_xattr.h"
 #include "../lib/crypto/crypto.h"
+#include "dbwrap.h"
+#include "auth.h"
+#include "util_tdb.h"
 
 #undef DBGC_CLASS
@@ -399 +404 @@
         .mkdir = mkdir_acl_common,
         .rmdir = rmdir_acl_tdb,
-        .open = open_acl_common,
+        .open_fn = open_acl_common,
         .create_file = create_file_acl_common,
         .unlink = unlink_acl_tdb,

trunk/server/source3/modules/vfs_acl_xattr.c

@@ -22 +22 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "librpc/gen_ndr/xattr.h"
 #include "librpc/gen_ndr/ndr_xattr.h"
 #include "../lib/crypto/crypto.h"
+#include "auth.h"
 
 #undef DBGC_CLASS
@@ -186 +188 @@
         }
 
-        /* Ensure we have the parameters correct if we're
-         * using this module. */
-        DEBUG(2,("connect_acl_xattr: setting 'inherit acls = true' "
-                "'dos filemode = true' and "
-                "'force unknown acl user = true' for service %s\n",
-                service ));
+        /* Ensure we have the parameters correct if we're
+         * using this module. */
+        DEBUG(2,("connect_acl_xattr: setting 'inherit acls = true' "
+                "'dos filemode = true' and "
+                "'force unknown acl user = true' for service %s\n",
+                service ));
 
         lp_do_parameter(SNUM(handle->conn), "inherit acls", "true");
@@ -205 +207 @@
         .mkdir = mkdir_acl_common,
         .rmdir = rmdir_acl_common,
-        .open = open_acl_common,
+        .open_fn = open_acl_common,
         .create_file = create_file_acl_common,
         .unlink = unlink_acl_common,

trunk/server/source3/modules/vfs_afsacl.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "../librpc/gen_ndr/lsa.h"
+#include "../libcli/security/security.h"
+#include "../libcli/security/dom_sid.h"
+#include "passdb.h"
 
 #undef DBGC_CLASS
@@ -31 +37 @@
 #define MAXSIZE 2048
 
-extern const DOM_SID global_sid_World;
-extern const DOM_SID global_sid_Builtin_Administrators;
-extern const DOM_SID global_sid_Builtin_Backup_Operators;
-extern const DOM_SID global_sid_Authenticated_Users;
-extern const DOM_SID global_sid_NULL;
+extern const struct dom_sid global_sid_World;
+extern const struct dom_sid global_sid_Builtin_Administrators;
+extern const struct dom_sid global_sid_Builtin_Backup_Operators;
+extern const struct dom_sid global_sid_Authenticated_Users;
+extern const struct dom_sid global_sid_NULL;
 
 static char space_replacement = '%';
@@ -47 +53 @@
         bool positive;
         char *name;
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         uint32 rights;
@@ -109 +115 @@
                                    const char *name, uint32 rights)
 {
-        DOM_SID sid;
+        struct dom_sid sid;
         enum lsa_SidType type;
         struct afs_ace *result;
@@ -418 +424 @@
 {
         return ( (x->positive == y->positive) &&
-                 (sid_compare(&x->sid, &y->sid) == 0) );
+                 (dom_sid_compare(&x->sid, &y->sid) == 0) );
 }
 
@@ -515 +521 @@
         /* FULL inherit only -- counterpart to previous one */
         { 0, SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY,
-          PERMS_FULL | GENERIC_RIGHT_WRITE_ACCESS, 127 /* rlidwka */ },
+          PERMS_FULL | SEC_GENERIC_WRITE, 127 /* rlidwka */ },
 
         /* CHANGE without inheritance -- in all cases here we also get
@@ -523 +529 @@
         /* CHANGE inherit only -- counterpart to previous one */
         { 0, SEC_ACE_FLAG_OBJECT_INHERIT|SEC_ACE_FLAG_CONTAINER_INHERIT|SEC_ACE_FLAG_INHERIT_ONLY,
-          PERMS_CHANGE | GENERIC_RIGHT_WRITE_ACCESS, 63 /* rlidwk */ },
+          PERMS_CHANGE | SEC_GENERIC_WRITE, 63 /* rlidwk */ },
 
         /* End marker, hopefully there's no afs right 9999 :-) */
@@ -529 +535 @@
 };
 
-static uint32 nt_to_afs_dir_rights(const char *filename, const SEC_ACE *ace)
+static uint32 nt_to_afs_dir_rights(const char *filename, const struct security_ace *ace)
 {
         uint32 result = 0;
@@ -570 +576 @@
 }
 
-static uint32 nt_to_afs_file_rights(const char *filename, const SEC_ACE *ace)
+static uint32 nt_to_afs_file_rights(const char *filename, const struct security_ace *ace)
 {
         uint32 result = 0;
@@ -591 +597 @@
                                    struct security_descriptor **ppdesc)
 {
-        SEC_ACE *nt_ace_list;
-        DOM_SID owner_sid, group_sid;
-        SEC_ACL *psa = NULL;
+        struct security_ace *nt_ace_list;
+        struct dom_sid owner_sid, group_sid;
+        struct security_acl *psa = NULL;
         int good_aces;
         size_t sd_size;
@@ -604 +610 @@
 
         if (afs_acl->num_aces) {
-                nt_ace_list = TALLOC_ARRAY(mem_ctx, SEC_ACE, afs_acl->num_aces);
+                nt_ace_list = TALLOC_ARRAY(mem_ctx, struct security_ace, afs_acl->num_aces);
 
                 if (nt_ace_list == NULL)
@@ -643 +649 @@
                 return 0;
 
-        *ppdesc = make_sec_desc(mem_ctx, SEC_DESC_REVISION,
+        *ppdesc = make_sec_desc(mem_ctx, SD_REVISION,
                                 SEC_DESC_SELF_RELATIVE,
-                                (security_info & OWNER_SECURITY_INFORMATION)
+                                (security_info & SECINFO_OWNER)
                                 ? &owner_sid : NULL,
-                                (security_info & GROUP_SECURITY_INFORMATION)
+                                (security_info & SECINFO_GROUP)
                                 ? &group_sid : NULL,
                                 NULL, psa, &sd_size);
@@ -683 +689 @@
         SMB_STRUCT_STAT sbuf;
 
-        if (fsp->is_directory || fsp->fh->fd == -1) {
+        if (fsp->fh->fd == -1) {
                 /* Get the stat struct for the owner info. */
                 return afs_to_nt_acl(afs_acl, fsp->conn, fsp->fsp_name,
@@ -696 +702 @@
 }
 
-static bool mappable_sid(const DOM_SID *sid)
-{
-        DOM_SID domain_sid;
+static bool mappable_sid(const struct dom_sid *sid)
+{
+        struct dom_sid domain_sid;
         
-        if (sid_compare(sid, &global_sid_Builtin_Administrators) == 0)
+        if (dom_sid_compare(sid, &global_sid_Builtin_Administrators) == 0)
                 return True;
 
-        if (sid_compare(sid, &global_sid_World) == 0)
+        if (dom_sid_compare(sid, &global_sid_World) == 0)
                 return True;
 
-        if (sid_compare(sid, &global_sid_Authenticated_Users) == 0)
+        if (dom_sid_compare(sid, &global_sid_Authenticated_Users) == 0)
                 return True;
 
-        if (sid_compare(sid, &global_sid_Builtin_Backup_Operators) == 0)
+        if (dom_sid_compare(sid, &global_sid_Builtin_Backup_Operators) == 0)
                 return True;
 
@@ -724 +730 @@
                           const struct security_descriptor *psd,
                           uint32 (*nt_to_afs_rights)(const char *filename,
-                                                     const SEC_ACE *ace),
+                                                     const struct security_ace *ace),
                           struct afs_acl *afs_acl)
 {
-        const SEC_ACL *dacl;
+        const struct security_acl *dacl;
         int i;
 
         /* Currently we *only* look at the dacl */
 
-        if (((security_info_sent & DACL_SECURITY_INFORMATION) == 0) ||
+        if (((security_info_sent & SECINFO_DACL) == 0) ||
             (psd->dacl == NULL))
                 return True;
@@ -742 +748 @@
 
         for (i = 0; i < dacl->num_aces; i++) {
-                const SEC_ACE *ace = &(dacl->aces[i]);
+                const struct security_ace *ace = &(dacl->aces[i]);
                 const char *dom_name, *name;
                 enum lsa_SidType name_type;
@@ -758 +764 @@
                 }
 
-                if (sid_compare(&ace->trustee,
+                if (dom_sid_compare(&ace->trustee,
                                 &global_sid_Builtin_Administrators) == 0) {
 
                         name = "system:administrators";
 
-                } else if (sid_compare(&ace->trustee,
+                } else if (dom_sid_compare(&ace->trustee,
                                        &global_sid_World) == 0) {
 
                         name = "system:anyuser";
 
-                } else if (sid_compare(&ace->trustee,
+                } else if (dom_sid_compare(&ace->trustee,
                                        &global_sid_Authenticated_Users) == 0) {
 
                         name = "system:authuser";
 
-                } else if (sid_compare(&ace->trustee,
+                } else if (dom_sid_compare(&ace->trustee,
                                        &global_sid_Builtin_Backup_Operators)
                            == 0) {
@@ -1057 +1063 @@
                          files_struct *fsp,
                          uint32 security_info_sent,
-                         const SEC_DESC *psd)
+                         const struct security_descriptor *psd)
 {
         return afs_set_nt_acl(handle, fsp, security_info_sent, psd);

trunk/server/source3/modules/vfs_aio_fork.c

@@ -3 +3 @@
  *
  * Copyright (C) Volker Lendecke 2008
+ * Copyright (C) Jeremy Allison 2010
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20 +21 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/shmem.h"
+#include "smbd/smbd.h"
+
+#ifndef MAP_FILE
+#define MAP_FILE 0
+#endif
 
 struct mmap_area {
@@ -246 +254 @@
 
                 TALLOC_FREE(child);
+                child = next;
         }
 
@@ -344 +353 @@
                                 fd, (void *)map->ptr, cmd_struct.n,
                                 cmd_struct.offset);
+#if 0
+/* This breaks "make test" when run with aio_fork module. */
 #ifdef ENABLE_BUILD_FARM_HACKS
                         ret_struct.size = MAX(1, ret_struct.size * 0.9);
+#endif
 #endif
                 }
@@ -383 +395 @@
                                   void *p)
 {
+        struct aio_extra *aio_ex = NULL;
         struct aio_child *child = (struct aio_child *)p;
-        uint16 mid;
+        NTSTATUS status;
 
         DEBUG(10, ("handle_aio_completion called with flags=%d\n", flags));
@@ -392 +405 @@
         }
 
-        if (!NT_STATUS_IS_OK(read_data(child->sockfd,
-                                       (char *)&child->retval,
-                                       sizeof(child->retval)))) {
-                DEBUG(0, ("aio child %d died\n", (int)child->pid));
+        status = read_data(child->sockfd, (char *)&child->retval,
+                           sizeof(child->retval));
+
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("aio child %d died: %s\n", (int)child->pid,
+                          nt_errstr(status)));
                 child->retval.size = -1;
                 child->retval.ret_errno = EIO;
+        }
+
+        if (child->aiocb == NULL) {
+                DEBUG(1, ("Inactive child died\n"));
+                TALLOC_FREE(child);
+                return;
         }
 
@@ -412 +433 @@
         }
 
-        mid = child->aiocb->aio_sigevent.sigev_value.sival_int;
-
-        DEBUG(10, ("mid %d finished\n", (int)mid));
-
-        smbd_aio_complete_mid(mid);
+        aio_ex = (struct aio_extra *)child->aiocb->aio_sigevent.sigev_value.sival_ptr;
+        smbd_aio_complete_aio_ex(aio_ex);
 }
 
 static int aio_child_destructor(struct aio_child *child)
 {
+        char c=0;
+
         SMB_ASSERT((child->aiocb == NULL) || child->cancelled);
+
+        DEBUG(10, ("aio_child_destructor: removing child %d on fd %d\n",
+                        child->pid, child->sockfd));
+
+        /*
+         * closing the sockfd makes the child not return from recvmsg() on RHEL
+         * 5.5 so instead force the child to exit by writing bad data to it
+         */
+        write(child->sockfd, &c, sizeof(c));
         close(child->sockfd);
         DLIST_REMOVE(child->list->children, child);
@@ -442 +471 @@
 }
 
-static NTSTATUS create_aio_child(struct aio_child_list *children,
+static NTSTATUS create_aio_child(struct smbd_server_connection *sconn,
+                                 struct aio_child_list *children,
                                  size_t map_size,
                                  struct aio_child **presult)
@@ -480 +510 @@
                 close(fdpair[0]);
                 result->sockfd = fdpair[1];
-                file_walk_table(close_fsp_fd, NULL);
+                files_forall(sconn, close_fsp_fd, NULL);
                 aio_child_loop(result->sockfd, result->map);
         }
 
-        DEBUG(10, ("Child %d created\n", result->pid));
+        DEBUG(10, ("Child %d created with sockfd %d\n",
+                        result->pid, fdpair[0]));
 
         result->sockfd = fdpair[0];
@@ -538 +569 @@
                 DEBUG(10, ("no idle child found, creating new one\n"));
 
-                status = create_aio_child(children, 128*1024, &child);
+                status = create_aio_child(handle->conn->sconn, children,
+                                          128*1024, &child);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(10, ("create_aio_child failed: %s\n",
@@ -725 +757 @@
 
         return child->retval.ret_errno;
+}
+
+static void aio_fork_suspend_timed_out(struct tevent_context *event_ctx,
+                                        struct tevent_timer *te,
+                                        struct timeval now,
+                                        void *private_data)
+{
+        bool *timed_out = (bool *)private_data;
+        /* Remove this timed event handler. */
+        TALLOC_FREE(te);
+        *timed_out = true;
+}
+
+static int aio_fork_suspend(struct vfs_handle_struct *handle,
+                        struct files_struct *fsp,
+                        const SMB_STRUCT_AIOCB * const aiocb_array[],
+                        int n,
+                        const struct timespec *timeout)
+{
+        struct aio_child_list *children = NULL;
+        TALLOC_CTX *frame = talloc_stackframe();
+        struct event_context *ev = NULL;
+        int i;
+        int ret = -1;
+        bool timed_out = false;
+
+        children = init_aio_children(handle);
+        if (children == NULL) {
+                errno = EINVAL;
+                goto out;
+        }
+
+        /* This is a blocking call, and has to use a sub-event loop. */
+        ev = event_context_init(frame);
+        if (ev == NULL) {
+                errno = ENOMEM;
+                goto out;
+        }
+
+        if (timeout) {
+                struct timeval tv = convert_timespec_to_timeval(*timeout);
+                struct tevent_timer *te = tevent_add_timer(ev,
+                                                frame,
+                                                timeval_current_ofs(tv.tv_sec,
+                                                                    tv.tv_usec),
+                                                aio_fork_suspend_timed_out,
+                                                &timed_out);
+                if (!te) {
+                        errno = ENOMEM;
+                        goto out;
+                }
+        }
+
+        for (i = 0; i < n; i++) {
+                struct aio_child *child = NULL;
+                const SMB_STRUCT_AIOCB *aiocb = aiocb_array[i];
+
+                if (!aiocb) {
+                        continue;
+                }
+
+                /*
+                 * We're going to cheat here. We know that smbd/aio.c
+                 * only calls this when it's waiting for every single
+                 * outstanding call to finish on a close, so just wait
+                 * individually for each IO to complete. We don't care
+                 * what order they finish - only that they all do. JRA.
+                 */
+
+                for (child = children->children; child != NULL; child = child->next) {
+                        if (child->aiocb == NULL) {
+                                continue;
+                        }
+                        if (child->aiocb->aio_fildes != fsp->fh->fd) {
+                                continue;
+                        }
+                        if (child->aiocb != aiocb) {
+                                continue;
+                        }
+
+                        if (child->aiocb->aio_sigevent.sigev_value.sival_ptr == NULL) {
+                                continue;
+                        }
+
+                        /* We're never using this event on the
+                         * main event context again... */
+                        TALLOC_FREE(child->sock_event);
+
+                        child->sock_event = event_add_fd(ev,
+                                                child,
+                                                child->sockfd,
+                                                EVENT_FD_READ,
+                                                handle_aio_completion,
+                                                child);
+
+                        while (1) {
+                                if (tevent_loop_once(ev) == -1) {
+                                        goto out;
+                                }
+
+                                if (timed_out) {
+                                        errno = EAGAIN;
+                                        goto out;
+                                }
+
+                                /* We set child->aiocb to NULL in our hooked
+                                 * AIO_RETURN(). */
+                                if (child->aiocb == NULL) {
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        ret = 0;
+
+  out:
+
+        TALLOC_FREE(frame);
+        return ret;
 }
 
@@ -733 +885 @@
         .aio_cancel = aio_fork_cancel,
         .aio_error_fn = aio_fork_error_fn,
+        .aio_suspend = aio_fork_suspend,
 };
 

trunk/server/source3/modules/vfs_aixacl.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 extern SMB_ACL_T aixacl_to_smbacl( struct acl *file_acl);

trunk/server/source3/modules/vfs_aixacl2.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "nfs4_acls.h"
 
@@ -156 +157 @@
 static NTSTATUS aixjfs2_fget_nt_acl(vfs_handle_struct *handle,
         files_struct *fsp, uint32 security_info,
-        SEC_DESC **ppdesc)
+        struct security_descriptor **ppdesc)
 {
         SMB4ACL_T *pacl = NULL;
@@ -178 +179 @@
 static NTSTATUS aixjfs2_get_nt_acl(vfs_handle_struct *handle,
         const char *name,
-        uint32 security_info, SEC_DESC **ppdesc)
+        uint32 security_info, struct security_descriptor **ppdesc)
 {
         SMB4ACL_T *pacl = NULL;
@@ -371 +372 @@
 }
 
-static NTSTATUS aixjfs2_set_nt_acl_common(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS aixjfs2_set_nt_acl_common(files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 {
         acl_type_t      acl_type_info;
@@ -395 +396 @@
 }
 
-NTSTATUS aixjfs2_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+NTSTATUS aixjfs2_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 {
         return aixjfs2_set_nt_acl_common(fsp, security_info_sent, psd);

trunk/server/source3/modules/vfs_aixacl_util.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 SMB_ACL_T aixacl_to_smbacl(struct acl *file_acl)

trunk/server/source3/modules/vfs_audit.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/syslog.h"
+#include "smbd/smbd.h"
 
 #undef DBGC_CLASS
@@ -268 +271 @@
         .mkdir = audit_mkdir,
         .rmdir = audit_rmdir,
-        .open = audit_open,
+        .open_fn = audit_open,
         .close_fn = audit_close,
         .rename = audit_rename,

trunk/server/source3/modules/vfs_cacheprime.c

@@ -17 +17 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 /* Cache priming module.

trunk/server/source3/modules/vfs_cap.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 /* cap functions */
@@ -385 +386 @@
 }
 
-static char *cap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
+static char *cap_realpath(vfs_handle_struct *handle, const char *path)
 {
         /* monyo need capencode'ed and capdecode'ed? */
@@ -394 +395 @@
                 return NULL;
         }
-        return SMB_VFS_NEXT_REALPATH(handle, path, resolved_path);
+        return SMB_VFS_NEXT_REALPATH(handle, cappath);
 }
 
@@ -576 +577 @@
         .mkdir = cap_mkdir,
         .rmdir = cap_rmdir,
-        .open = cap_open,
+        .open_fn = cap_open,
         .rename = cap_rename,
         .stat = cap_stat,

trunk/server/source3/modules/vfs_catia.c

@@ -28 +28 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 #define GLOBAL_SNUM     0xFFFFFFF
@@ -236 +237 @@
 
         if ((push_ucs2_talloc(ctx, &tmpbuf, name_in,
-                              &converted_size)) == -1) {
+                              &converted_size)) == false) {
                 return map_nt_error_from_unix(errno);
         }
@@ -253 +254 @@
 
         if ((pull_ucs2_talloc(ctx, mapped_name, tmpbuf,
-                              &converted_size)) == -1) {
+                              &converted_size)) == false) {
                 TALLOC_FREE(tmpbuf);
                 return map_nt_error_from_unix(errno);
@@ -635 +636 @@
 
 static char *
-catia_realpath(vfs_handle_struct *handle, const char *path,
-               char *resolved_path)
+catia_realpath(vfs_handle_struct *handle, const char *path)
 {
         char *mapped_name = NULL;
@@ -649 +649 @@
         }
 
-        ret = SMB_VFS_NEXT_REALPATH(handle, mapped_name, resolved_path);
+        ret = SMB_VFS_NEXT_REALPATH(handle, mapped_name);
         TALLOC_FREE(mapped_name);
 
@@ -991 +991 @@
         .rmdir = catia_rmdir,
         .opendir = catia_opendir,
-        .open = catia_open,
+        .open_fn = catia_open,
         .rename = catia_rename,
         .stat = catia_stat,

trunk/server/source3/modules/vfs_commit.c

@@ -18 +18 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 /* Commit data module.
@@ -89 +91 @@
         result = fsync(fd);
 #else
+        DEBUG(0, ("%s: WARNING: no commit support on this platform\n",
+                MODULE));
         result = 0
 #endif
@@ -302 +306 @@
 
 static struct vfs_fn_pointers vfs_commit_fns = {
-        .open = commit_open,
+        .open_fn = commit_open,
         .close_fn = commit_close,
         .write = commit_write,

trunk/server/source3/modules/vfs_default.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "system/time.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "ntioctl.h"
+#include "smbprofile.h"
 
 #undef DBGC_CLASS
@@ -80 +85 @@
 }
 
-static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, bool labels)
+static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
+                                        struct files_struct *fsp,
+                                        struct shadow_copy_data *shadow_copy_data,
+                                        bool labels)
 {
         errno = ENOSYS;
@@ -168 +176 @@
 }
 
+static SMB_STRUCT_DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
+                        files_struct *fsp,
+                        const char *mask,
+                        uint32 attr)
+{
+        SMB_STRUCT_DIR *result;
+
+        START_PROFILE(syscall_fdopendir);
+        result = sys_fdopendir(fsp->fh->fd);
+        END_PROFILE(syscall_fdopendir);
+        return result;
+}
+
+
 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle,
                                           SMB_STRUCT_DIR *dirp,
@@ -299 +321 @@
                                     uint32_t oplock_request,
                                     uint64_t allocation_size,
+                                    uint32_t private_flags,
                                     struct security_descriptor *sd,
                                     struct ea_list *ea_list,
@@ -308 +331 @@
                                    create_disposition, create_options,
                                    file_attributes, oplock_request,
-                                   allocation_size, sd, ea_list, result,
+                                   allocation_size, private_flags,
+                                   sd, ea_list, result,
                                    pinfo);
 }
@@ -476 +500 @@
 }
 
-/*********************************************************
- For rename across filesystems Patch from Warren Birnbaum
- <warrenb@hpcvscdp.cv.hp.com>
-**********************************************************/
-
-static int copy_reg(const char *source, const char *dest)
-{
-        SMB_STRUCT_STAT source_stats;
-        int saved_errno;
-        int ifd = -1;
-        int ofd = -1;
-
-        if (sys_lstat(source, &source_stats, false) == -1)
-                return -1;
-
-        if (!S_ISREG (source_stats.st_ex_mode))
-                return -1;
-
-        if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
-                return -1;
-
-        if (unlink (dest) && errno != ENOENT)
-                return -1;
-
-#ifdef O_NOFOLLOW
-        if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
-#else
-        if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
-#endif
-                goto err;
-
-        if (transfer_file(ifd, ofd, (size_t)-1) == -1)
-                goto err;
-
-        /*
-         * Try to preserve ownership.  For non-root it might fail, but that's ok.
-         * But root probably wants to know, e.g. if NFS disallows it.
-         */
-
-#ifdef HAVE_FCHOWN
-        if ((fchown(ofd, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
-#else
-        if ((chown(dest, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
-#endif
-                goto err;
-
-        /*
-         * fchown turns off set[ug]id bits for non-root,
-         * so do the chmod last.
-         */
-
-#if defined(HAVE_FCHMOD)
-        if (fchmod (ofd, source_stats.st_ex_mode & 07777))
-#else
-        if (chmod (dest, source_stats.st_ex_mode & 07777))
-#endif
-                goto err;
-
-        if (close (ifd) == -1)
-                goto err;
-
-        if (close (ofd) == -1)
-                return -1;
-
-        /* Try to copy the old file's modtime and access time.  */
-#if defined(HAVE_UTIMENSAT)
-        {
-                struct timespec ts[2];
-
-                ts[0] = source_stats.st_ex_atime;
-                ts[1] = source_stats.st_ex_mtime;
-                utimensat(AT_FDCWD, dest, ts, AT_SYMLINK_NOFOLLOW);
-        }
-#elif defined(HAVE_UTIMES)
-        {
-                struct timeval tv[2];
-
-                tv[0] = convert_timespec_to_timeval(source_stats.st_ex_atime);
-                tv[1] = convert_timespec_to_timeval(source_stats.st_ex_mtime);
-#ifdef HAVE_LUTIMES
-                lutimes(dest, tv);
-#else
-                utimes(dest, tv);
-#endif
-        }
-#elif defined(HAVE_UTIME)
-        {
-                struct utimbuf tv;
-
-                tv.actime = convert_timespec_to_time_t(source_stats.st_ex_atime);
-                tv.modtime = convert_timespec_to_time_t(source_stats.st_ex_mtime);
-                utime(dest, &tv);
-        }
-#endif
-
-        if (unlink (source) == -1)
-                return -1;
-
-        return 0;
-
-  err:
-
-        saved_errno = errno;
-        if (ifd != -1)
-                close(ifd);
-        if (ofd != -1)
-                close(ofd);
-        errno = saved_errno;
-        return -1;
-}
-
 static int vfswrap_rename(vfs_handle_struct *handle,
                           const struct smb_filename *smb_fname_src,
@@ -601 +514 @@
 
         result = rename(smb_fname_src->base_name, smb_fname_dst->base_name);
-        if ((result == -1) && (errno == EXDEV)) {
-                /* Rename across filesystems needed. */
-                result = copy_reg(smb_fname_src->base_name,
-                                  smb_fname_dst->base_name);
-        }
 
  out:
@@ -869 +777 @@
         }
 
-        if (null_timespec(ft->atime)) {
-                ft->atime= smb_fname->st.st_ex_atime;
-        }
-
-        if (null_timespec(ft->mtime)) {
-                ft->mtime = smb_fname->st.st_ex_mtime;
-        }
-
-        if (!null_timespec(ft->create_time)) {
-                set_create_timespec_ea(handle->conn,
-                                smb_fname,
-                                ft->create_time);
-        }
-
-        if ((timespec_compare(&ft->atime,
-                                &smb_fname->st.st_ex_atime) == 0) &&
-                        (timespec_compare(&ft->mtime,
-                                &smb_fname->st.st_ex_mtime) == 0)) {
-                return 0;
+        if (ft != NULL) {
+                if (null_timespec(ft->atime)) {
+                        ft->atime= smb_fname->st.st_ex_atime;
+                }
+
+                if (null_timespec(ft->mtime)) {
+                        ft->mtime = smb_fname->st.st_ex_mtime;
+                }
+
+                if (!null_timespec(ft->create_time)) {
+                        set_create_timespec_ea(handle->conn,
+                                               smb_fname,
+                                               ft->create_time);
+                }
+
+                if ((timespec_compare(&ft->atime,
+                                      &smb_fname->st.st_ex_atime) == 0) &&
+                    (timespec_compare(&ft->mtime,
+                                      &smb_fname->st.st_ex_mtime) == 0)) {
+                        return 0;
+                }
         }
 
@@ -944 +854 @@
 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 {
-        SMB_STRUCT_STAT st;
-        SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
-        unsigned char zero_space[4096];
         SMB_OFF_T space_to_write;
         uint64_t space_avail;
         uint64_t bsize,dfree,dsize;
         int ret;
-
-        if (currpos == -1)
+        NTSTATUS status;
+        SMB_STRUCT_STAT *pst;
+
+        status = vfs_stat_fsp(fsp);
+        if (!NT_STATUS_IS_OK(status)) {
                 return -1;
-
-        if (SMB_VFS_FSTAT(fsp, &st) == -1)
-                return -1;
+        }
+        pst = &fsp->fsp_name->st;
 
 #ifdef S_ISFIFO
-        if (S_ISFIFO(st.st_ex_mode))
+        if (S_ISFIFO(pst->st_ex_mode))
                 return 0;
 #endif
 
-        if (st.st_ex_size == len)
+        if (pst->st_ex_size == len)
                 return 0;
 
         /* Shrink - just ftruncate. */
-        if (st.st_ex_size > len)
+        if (pst->st_ex_size > len)
                 return sys_ftruncate(fsp->fh->fd, len);
 
-        space_to_write = len - st.st_ex_size;
-
-        /* for allocation try posix_fallocate first. This can fail on some
+        space_to_write = len - pst->st_ex_size;
+
+        /* for allocation try fallocate first. This can fail on some
            platforms e.g. when the filesystem doesn't support it and no
            emulation is being done by the libc (like on AIX with JFS1). In that
-           case we do our own emulation. posix_fallocate implementations can
+           case we do our own emulation. fallocate implementations can
            return ENOTSUP or EINVAL in cases like that. */
-        ret = sys_posix_fallocate(fsp->fh->fd, st.st_ex_size, space_to_write);
+        ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
+                                pst->st_ex_size, space_to_write);
         if (ret == ENOSPC) {
                 errno = ENOSPC;
@@ -985 +895 @@
                 return 0;
         }
-        DEBUG(10,("strict_allocate_ftruncate: sys_posix_fallocate failed with "
+        DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
                 "error %d. Falling back to slow manual allocation\n", ret));
 
@@ -1000 +910 @@
 
         /* Write out the real space on disk. */
-        if (SMB_VFS_LSEEK(fsp, st.st_ex_size, SEEK_SET) != st.st_ex_size)
-                return -1;
-
-        memset(zero_space, '\0', sizeof(zero_space));
-        while ( space_to_write > 0) {
-                SMB_OFF_T retlen;
-                SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
-
-                retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
-                if (retlen <= 0)
-                        return -1;
-
-                space_to_write -= retlen;
-        }
-
-        /* Seek to where we were */
-        if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
-                return -1;
+        ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
+        if (ret != 0) {
+                errno = ret;
+                ret = -1;
+        }
 
         return 0;
@@ -1025 +922 @@
 {
         int result = -1;
-        SMB_STRUCT_STAT st;
+        SMB_STRUCT_STAT *pst;
+        NTSTATUS status;
         char c = 0;
-        SMB_OFF_T currpos;
 
         START_PROFILE(syscall_ftruncate);
 
-        if (lp_strict_allocate(SNUM(fsp->conn))) {
+        if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->is_sparse) {
                 result = strict_allocate_ftruncate(handle, fsp, len);
                 END_PROFILE(syscall_ftruncate);
@@ -1050 +947 @@
            extend a file with ftruncate. Provide alternate implementation
            for this */
-        currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
-        if (currpos == -1) {
-                goto done;
-        }
 
         /* Do an fstat to see if the file is longer than the requested
@@ -1059 +952 @@
            succeeded or shorter, in which case seek to len - 1 and
            write 1 byte of zero */
-        if (SMB_VFS_FSTAT(fsp, &st) == -1) {
+        status = vfs_stat_fsp(fsp);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto done;
         }
+        pst = &fsp->fsp_name->st;
 
 #ifdef S_ISFIFO
-        if (S_ISFIFO(st.st_ex_mode)) {
+        if (S_ISFIFO(pst->st_ex_mode)) {
                 result = 0;
                 goto done;
@@ -1070 +965 @@
 #endif
 
-        if (st.st_ex_size == len) {
+        if (pst->st_ex_size == len) {
                 result = 0;
                 goto done;
         }
 
-        if (st.st_ex_size > len) {
+        if (pst->st_ex_size > len) {
                 /* the sys_ftruncate should have worked */
                 goto done;
         }
 
-        if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
+        if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
                 goto done;
-
-        if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
-                goto done;
-
-        /* Seek to where we were */
-        if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
-                goto done;
+        }
+
         result = 0;
 
@@ -1094 +984 @@
 
         END_PROFILE(syscall_ftruncate);
+        return result;
+}
+
+static int vfswrap_fallocate(vfs_handle_struct *handle,
+                        files_struct *fsp,
+                        enum vfs_fallocate_mode mode,
+                        SMB_OFF_T offset,
+                        SMB_OFF_T len)
+{
+        int result;
+
+        START_PROFILE(syscall_fallocate);
+        if (mode == VFS_FALLOCATE_EXTEND_SIZE) {
+                result = sys_posix_fallocate(fsp->fh->fd, offset, len);
+        } else if (mode == VFS_FALLOCATE_KEEP_SIZE) {
+                result = sys_fallocate(fsp->fh->fd, mode, offset, len);
+        } else {
+                errno = EINVAL;
+                result = -1;
+        }
+        END_PROFILE(syscall_fallocate);
         return result;
 }
@@ -1187 +1098 @@
 }
 
-static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path, char *resolved_path)
+static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path)
 {
         char *result;
 
         START_PROFILE(syscall_realpath);
-        result = realpath(path, resolved_path);
+#ifdef REALPATH_TAKES_NULL
+        result = realpath(path, NULL);
+#else
+        result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
+        if (result) {
+                char *resolved_path = realpath(path, result);
+                if (!resolved_path) {
+                        SAFE_FREE(result);
+                } else {
+                        /* SMB_ASSERT(result == resolved_path) ? */
+                        result = resolved_path;
+                }
+        }
+#endif
         END_PROFILE(syscall_realpath);
         return result;
@@ -1394 +1318 @@
 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
                                     files_struct *fsp,
-                                    uint32 security_info, SEC_DESC **ppdesc)
+                                    uint32 security_info,
+                                    struct security_descriptor **ppdesc)
 {
         NTSTATUS result;
@@ -1406 +1331 @@
 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
                                    const char *name,
-                                   uint32 security_info, SEC_DESC **ppdesc)
+                                   uint32 security_info,
+                                   struct security_descriptor **ppdesc)
 {
         NTSTATUS result;
@@ -1416 +1342 @@
 }
 
-static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 {
         NTSTATUS result;
@@ -1590 +1516 @@
 }
 
-ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
+static ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
 {
         return sys_llistxattr(path, list, size);
 }
 
-ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
+static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
 {
         return sys_flistxattr(fsp->fh->fd, list, size);
@@ -1690 +1616 @@
 }
 
-static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
-{
-        if (ISDOT(path) || ISDOTDOT(path)) {
+static bool vfswrap_is_offline(struct vfs_handle_struct *handle,
+                               const struct smb_filename *fname,
+                               SMB_STRUCT_STAT *sbuf)
+{
+        NTSTATUS status;
+        char *path;
+
+        if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
                 return false;
         }
@@ -1703 +1634 @@
         }
 
+        status = get_full_smb_filename(talloc_tos(), fname, &path);
+        if (!NT_STATUS_IS_OK(status)) {
+                errno = map_errno_from_nt_status(status);
+                return false;
+        }
+
         return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
 }
 
-static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
+static int vfswrap_set_offline(struct vfs_handle_struct *handle,
+                               const struct smb_filename *fname)
 {
         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
@@ -1730 +1668 @@
 
         .opendir = vfswrap_opendir,
+        .fdopendir = vfswrap_fdopendir,
         .readdir = vfswrap_readdir,
         .seekdir = vfswrap_seekdir,
@@ -1741 +1680 @@
         /* File operations */
 
-        .open = vfswrap_open,
+        .open_fn = vfswrap_open,
         .create_file = vfswrap_create_file,
         .close_fn = vfswrap_close,
@@ -1767 +1706 @@
         .ntimes = vfswrap_ntimes,
         .ftruncate = vfswrap_ftruncate,
+        .fallocate = vfswrap_fallocate,
         .lock = vfswrap_lock,
         .kernel_flock = vfswrap_kernel_flock,

trunk/server/source3/modules/vfs_default_quota.c

@@ -69 +69 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 #undef DBGC_CLASS

trunk/server/source3/modules/vfs_dirsort.c

@@ -20 +20 @@
 
 #include "includes.h"
-
-static int compare_dirent (const void *a, const void *b) {
-        const SMB_STRUCT_DIRENT *da = (const SMB_STRUCT_DIRENT *) a;
-        const SMB_STRUCT_DIRENT *db = (const SMB_STRUCT_DIRENT *) b;
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+
+static int compare_dirent (const SMB_STRUCT_DIRENT *da, const SMB_STRUCT_DIRENT *db)
+{
         return StrCaseCmp(da->d_name, db->d_name);
 }
@@ -45 +46 @@
 }
 
-static void open_and_sort_dir (vfs_handle_struct *handle)
+static bool open_and_sort_dir (vfs_handle_struct *handle)
 {
         SMB_STRUCT_DIRENT *dp;
@@ -52 +53 @@
         struct dirsort_privates *data = NULL;
 
-        SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates, return);
+        SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates,
+                                return false);
 
         data->number_of_entries = 0;
@@ -73 +75 @@
         data->directory_list = (SMB_STRUCT_DIRENT *)SMB_MALLOC(
                 data->number_of_entries * sizeof(SMB_STRUCT_DIRENT));
+        if (!data->directory_list) {
+                return false;
+        }
         current_pos = data->pos;
         data->pos = 0;
@@ -82 +87 @@
         /* Sort the directory entries by name */
         data->pos = current_pos;
-        qsort(data->directory_list, data->number_of_entries,
-              sizeof(SMB_STRUCT_DIRENT), compare_dirent);
+        TYPESAFE_QSORT(data->directory_list, data->number_of_entries, compare_dirent);
+        return true;
 }
 
@@ -96 +101 @@
                 sizeof(struct dirsort_privates));
 
+        if (!data) {
+                return NULL;
+        }
+
         data->directory_list = NULL;
         data->pos = 0;
@@ -108 +117 @@
                                 struct dirsort_privates, return NULL);
 
-        open_and_sort_dir(handle);
+        if (!open_and_sort_dir(handle)) {
+                SMB_VFS_NEXT_CLOSEDIR(handle,data->source_directory);
+                return NULL;
+        }
+
+        return data->source_directory;
+}
+
+static SMB_STRUCT_DIR *dirsort_fdopendir(vfs_handle_struct *handle,
+                                        files_struct *fsp,
+                                        const char *mask,
+                                        uint32 attr)
+{
+        struct dirsort_privates *data = NULL;
+
+        /* set up our private data about this directory */
+        data = (struct dirsort_privates *)SMB_MALLOC(
+                sizeof(struct dirsort_privates));
+
+        if (!data) {
+                return NULL;
+        }
+
+        data->directory_list = NULL;
+        data->pos = 0;
+
+        /* Open the underlying directory and count the number of entries */
+        data->source_directory = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask,
+                                                      attr);
+
+        if (data->source_directory == NULL) {
+                SAFE_FREE(data);
+                return NULL;
+        }
+
+        data->fd = dirfd(data->source_directory);
+
+        SMB_VFS_HANDLE_SET_DATA(handle, data, free_dirsort_privates,
+                                struct dirsort_privates, return NULL);
+
+        if (!open_and_sort_dir(handle)) {
+                SMB_VFS_NEXT_CLOSEDIR(handle,data->source_directory);
+                /* fd is now closed. */
+                fsp->fh->fd = -1;
+                return NULL;
+        }
 
         return data->source_directory;
@@ -170 +224 @@
 static struct vfs_fn_pointers vfs_dirsort_fns = {
         .opendir = dirsort_opendir,
+        .fdopendir = dirsort_fdopendir,
         .readdir = dirsort_readdir,
         .seekdir = dirsort_seekdir,

trunk/server/source3/modules/vfs_expand_msdfs.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "smbd/globals.h"
+#include "auth.h"
 
 #undef DBGC_CLASS
@@ -36 +41 @@
 ***********************************************************/
 
-static char *read_target_host(TALLOC_CTX *ctx, const char *mapfile)
+static char *read_target_host(TALLOC_CTX *ctx, const char *mapfile,
+                              const char *clientaddr)
 {
         XFILE *f;
@@ -54 +60 @@
 
         while (x_fgets(buf, sizeof(buf), f) != NULL) {
-                char addr[INET6_ADDRSTRLEN];
 
                 if ((strlen(buf) > 0) && (buf[strlen(buf)-1] == '\n'))
@@ -70 +75 @@
                 *space = '\0';
 
-                if (strncmp(client_addr(get_client_fd(),addr,sizeof(addr)),
-                                buf, strlen(buf)) == 0) {
+                if (strncmp(clientaddr, buf, strlen(buf)) == 0) {
                         found = true;
                         break;
@@ -136 +140 @@
         DEBUG(10, ("Expanding from table [%s]\n", mapfilename));
 
-        if ((targethost = read_target_host(ctx, mapfilename)) == NULL) {
+        targethost = read_target_host(
+                ctx, conn->sconn->client_id.addr, mapfilename);
+        if (targethost == NULL) {
                 DEBUG(1, ("Could not expand target host from file %s\n",
                           mapfilename));
@@ -144 +150 @@
         targethost = talloc_sub_advanced(ctx,
                                 lp_servicename(SNUM(conn)),
-                                conn->server_info->unix_name,
+                                conn->session_info->unix_name,
                                 conn->connectpath,
-                                conn->server_info->utok.gid,
-                                conn->server_info->sanitized_username,
-                                pdb_get_domain(conn->server_info->sam_account),
+                                conn->session_info->utok.gid,
+                                conn->session_info->sanitized_username,
+                                conn->session_info->info3->base.domain.string,
                                 targethost);
 

trunk/server/source3/modules/vfs_extd_audit.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/syslog.h"
+#include "smbd/smbd.h"
 
 static int vfs_extd_audit_debug_level = DBGC_VFS;
@@ -345 +348 @@
         .mkdir = audit_mkdir,
         .rmdir = audit_rmdir,
-        .open = audit_open,
+        .open_fn = audit_open,
         .close_fn = audit_close,
         .rename = audit_rename,

trunk/server/source3/modules/vfs_fake_perms.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "auth.h"
 
 #undef DBGC_CLASS
@@ -39 +42 @@
                         smb_fname->st.st_ex_mode = S_IRWXU;
                 }
-                smb_fname->st.st_ex_uid = handle->conn->server_info->utok.uid;
-                smb_fname->st.st_ex_gid = handle->conn->server_info->utok.gid;
+                smb_fname->st.st_ex_uid = handle->conn->session_info->utok.uid;
+                smb_fname->st.st_ex_gid = handle->conn->session_info->utok.gid;
         }
 
@@ -57 +60 @@
                         sbuf->st_ex_mode = S_IRWXU;
                 }
-                sbuf->st_ex_uid = handle->conn->server_info->utok.uid;
-                sbuf->st_ex_gid = handle->conn->server_info->utok.gid;
+                sbuf->st_ex_uid = handle->conn->session_info->utok.uid;
+                sbuf->st_ex_gid = handle->conn->session_info->utok.gid;
         }
         return ret;

trunk/server/source3/modules/vfs_fileid.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
 
 static int vfs_fileid_debug_level = DBGC_VFS;

trunk/server/source3/modules/vfs_full_audit.c

@@ -59 +59 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/syslog.h"
+#include "smbd/smbd.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "auth.h"
+#include "ntioctl.h"
 
 static int vfs_full_audit_debug_level = DBGC_VFS;
@@ -87 +93 @@
 
         SMB_VFS_OP_OPENDIR,
+        SMB_VFS_OP_FDOPENDIR,
         SMB_VFS_OP_READDIR,
         SMB_VFS_OP_SEEKDIR,
@@ -124 +131 @@
         SMB_VFS_OP_NTIMES,
         SMB_VFS_OP_FTRUNCATE,
+        SMB_VFS_OP_FALLOCATE,
         SMB_VFS_OP_LOCK,
         SMB_VFS_OP_KERNEL_FLOCK,
@@ -228 +236 @@
         { SMB_VFS_OP_FS_CAPABILITIES,   "fs_capabilities" },
         { SMB_VFS_OP_OPENDIR,   "opendir" },
+        { SMB_VFS_OP_FDOPENDIR, "fdopendir" },
         { SMB_VFS_OP_READDIR,   "readdir" },
         { SMB_VFS_OP_SEEKDIR,   "seekdir" },
@@ -262 +271 @@
         { SMB_VFS_OP_NTIMES,    "ntimes" },
         { SMB_VFS_OP_FTRUNCATE, "ftruncate" },
+        { SMB_VFS_OP_FALLOCATE,"fallocate" },
         { SMB_VFS_OP_LOCK,      "lock" },
         { SMB_VFS_OP_KERNEL_FLOCK,      "kernel_flock" },
@@ -330 +340 @@
         { SMB_VFS_OP_AIO_SUSPEND,"aio_suspend" },
         { SMB_VFS_OP_AIO_FORCE, "aio_force" },
-        { SMB_VFS_OP_IS_OFFLINE, "aio_is_offline" },
-        { SMB_VFS_OP_SET_OFFLINE, "aio_set_offline" },
+        { SMB_VFS_OP_IS_OFFLINE, "is_offline" },
+        { SMB_VFS_OP_SET_OFFLINE, "set_offline" },
         { SMB_VFS_OP_LAST, NULL }
 };
@@ -393 +403 @@
         result = talloc_sub_advanced(ctx,
                         lp_servicename(SNUM(conn)),
-                        conn->server_info->unix_name,
+                        conn->session_info->unix_name,
                         conn->connectpath,
-                        conn->server_info->utok.gid,
-                        conn->server_info->sanitized_username,
-                        pdb_get_domain(conn->server_info->sam_account),
+                        conn->session_info->utok.gid,
+                        conn->session_info->sanitized_username,
+                        conn->session_info->info3->base.domain.string,
                         prefix);
         TALLOC_FREE(prefix);
@@ -432 +442 @@
 }
 
-static void init_bitmap(struct bitmap **bm, const char **ops)
-{
-        bool log_all = False;
-
-        if (*bm != NULL)
-                return;
-
-        *bm = bitmap_allocate(SMB_VFS_OP_LAST);
-
-        if (*bm == NULL) {
+static struct bitmap *init_bitmap(TALLOC_CTX *mem_ctx, const char **ops)
+{
+        struct bitmap *bm;
+
+        if (ops == NULL) {
+                return NULL;
+        }
+
+        bm = bitmap_talloc(mem_ctx, SMB_VFS_OP_LAST);
+        if (bm == NULL) {
                 DEBUG(0, ("Could not alloc bitmap -- "
                           "defaulting to logging everything\n"));
-                return;
+                return NULL;
         }
 
-        while (*ops != NULL) {
+        for (; *ops != NULL; ops += 1) {
                 int i;
-                bool found = False;
+                bool neg = false;
+                const char *op;
 
                 if (strequal(*ops, "all")) {
-                        log_all = True;
+                        for (i=0; i<SMB_VFS_OP_LAST; i++) {
+                                bitmap_set(bm, i);
+                        }
+                        continue;
+                }
+
+                if (strequal(*ops, "none")) {
                         break;
                 }
 
-                if (strequal(*ops, "none")) {
-                        break;
+                op = ops[0];
+                if (op[0] == '!') {
+                        neg = true;
+                        op += 1;
                 }
 
@@ -465 +484 @@
                                           "in sync with vfs.h\n");
                         }
-
-                        if (strequal(*ops, vfs_op_names[i].name)) {
-                                bitmap_set(*bm, i);
-                                found = True;
+                        if (strequal(op, vfs_op_names[i].name)) {
+                                if (neg) {
+                                        bitmap_clear(bm, i);
+                                } else {
+                                        bitmap_set(bm, i);
+                                }
+                                break;
                         }
                 }
-                if (!found) {
+                if (i == SMB_VFS_OP_LAST) {
                         DEBUG(0, ("Could not find opname %s, logging all\n",
                                   *ops));
-                        log_all = True;
-                        break;
+                        TALLOC_FREE(bm);
+                        return NULL;
                 }
-                ops += 1;
         }
-
-        if (log_all) {
-                /* The query functions default to True */
-                bitmap_free(*bm);
-                *bm = NULL;
-        }
+        return bm;
 }
 
@@ -580 +596 @@
 }
 
-/* Free function for the private data. */
-
-static void free_private_data(void **p_data)
-{
-        struct vfs_full_audit_private_data *pd = *(struct vfs_full_audit_private_data **)p_data;
-
-        if (pd->success_ops) {
-                bitmap_free(pd->success_ops);
-        }
-        if (pd->failure_ops) {
-                bitmap_free(pd->failure_ops);
-        }
-        SAFE_FREE(pd);
-        *p_data = NULL;
-}
-
 /* Implementation of vfs_ops.  Pass everything on to the default
    operation but log event first. */
@@ -604 +604 @@
         int result;
         struct vfs_full_audit_private_data *pd = NULL;
-        const char *none[] = { NULL };
-        const char *all [] = { "all" };
 
         result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
@@ -612 +610 @@
         }
 
-        pd = SMB_MALLOC_P(struct vfs_full_audit_private_data);
+        pd = TALLOC_ZERO_P(handle, struct vfs_full_audit_private_data);
         if (!pd) {
                 SMB_VFS_NEXT_DISCONNECT(handle);
                 return -1;
         }
-        ZERO_STRUCTP(pd);
 
 #ifndef WITH_SYSLOG
@@ -623 +620 @@
 #endif
 
-        init_bitmap(&pd->success_ops,
-                    lp_parm_string_list(SNUM(handle->conn), "full_audit", "success",
-                                        none));
-        init_bitmap(&pd->failure_ops,
-                    lp_parm_string_list(SNUM(handle->conn), "full_audit", "failure",
-                                        all));
+        pd->success_ops = init_bitmap(
+                pd, lp_parm_string_list(SNUM(handle->conn), "full_audit",
+                                        "success", NULL));
+        pd->failure_ops = init_bitmap(
+                pd, lp_parm_string_list(SNUM(handle->conn), "full_audit",
+                                        "failure", NULL));
 
         /* Store the private data. */
-        SMB_VFS_HANDLE_SET_DATA(handle, pd, free_private_data,
+        SMB_VFS_HANDLE_SET_DATA(handle, pd, NULL,
                                 struct vfs_full_audit_private_data, return -1);
 
@@ -699 +696 @@
 static int smb_full_audit_get_shadow_copy_data(struct vfs_handle_struct *handle,
                                 struct files_struct *fsp,
-                                SHADOW_COPY_DATA *shadow_copy_data, bool labels)
+                                struct shadow_copy_data *shadow_copy_data,
+                                bool labels)
 {
         int result;
@@ -742 +740 @@
 
         do_log(SMB_VFS_OP_OPENDIR, (result != NULL), handle, "%s", fname);
+
+        return result;
+}
+
+static SMB_STRUCT_DIR *smb_full_audit_fdopendir(vfs_handle_struct *handle,
+                          files_struct *fsp, const char *mask, uint32 attr)
+{
+        SMB_STRUCT_DIR *result;
+
+        result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
+
+        do_log(SMB_VFS_OP_FDOPENDIR, (result != NULL), handle, "%s",
+                        fsp_str_do_log(fsp));
 
         return result;
@@ -862 +873 @@
                                       uint32_t oplock_request,
                                       uint64_t allocation_size,
+                                      uint32_t private_flags,
                                       struct security_descriptor *sd,
                                       struct ea_list *ea_list,
@@ -905 +917 @@
                 oplock_request,                         /* oplock_request */
                 allocation_size,                        /* allocation_size */
+                private_flags,
                 sd,                                     /* sd */
                 ea_list,                                /* ea_list */
@@ -1099 +1112 @@
         result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
 
-        do_log(SMB_VFS_OP_GET_ALLOC_SIZE, (result >= 0), handle, "%d", result);
+        do_log(SMB_VFS_OP_GET_ALLOC_SIZE, (result != (uint64_t)-1), handle,
+                        "%llu", result);
 
         return result;
@@ -1232 +1246 @@
 }
 
+static int smb_full_audit_fallocate(vfs_handle_struct *handle, files_struct *fsp,
+                           enum vfs_fallocate_mode mode,
+                           SMB_OFF_T offset,
+                           SMB_OFF_T len)
+{
+        int result;
+
+        result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
+
+        do_log(SMB_VFS_OP_FALLOCATE, (result >= 0), handle,
+               "%s", fsp_str_do_log(fsp));
+
+        return result;
+}
+
 static bool smb_full_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
                        int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
@@ -1334 +1363 @@
 
 static char *smb_full_audit_realpath(vfs_handle_struct *handle,
-                            const char *path, char *resolved_path)
+                            const char *path)
 {
         char *result;
 
-        result = SMB_VFS_NEXT_REALPATH(handle, path, resolved_path);
+        result = SMB_VFS_NEXT_REALPATH(handle, path);
 
         do_log(SMB_VFS_OP_REALPATH, (result != NULL), handle, "%s", path);
@@ -1536 +1565 @@
 static NTSTATUS smb_full_audit_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
                                 uint32 security_info,
-                                SEC_DESC **ppdesc)
+                                struct security_descriptor **ppdesc)
 {
         NTSTATUS result;
@@ -1551 +1580 @@
                                           const char *name,
                                           uint32 security_info,
-                                          SEC_DESC **ppdesc)
+                                          struct security_descriptor **ppdesc)
 {
         NTSTATUS result;
@@ -1565 +1594 @@
 static NTSTATUS smb_full_audit_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
                               uint32 security_info_sent,
-                              const SEC_DESC *psd)
+                              const struct security_descriptor *psd)
 {
         NTSTATUS result;
@@ -2178 +2207 @@
                 "%s", fsp_str_do_log(fsp));
 
+        return result;
+}
+
+static bool smb_full_audit_is_offline(struct vfs_handle_struct *handle,
+                                      const struct smb_filename *fname,
+                                      SMB_STRUCT_STAT *sbuf)
+{
+        bool result;
+
+        result = SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
+        do_log(SMB_VFS_OP_IS_OFFLINE, result, handle, "%s",
+               smb_fname_str_do_log(fname));
+        return result;
+}
+
+static int smb_full_audit_set_offline(struct vfs_handle_struct *handle,
+                                      const struct smb_filename *fname)
+{
+        int result;
+
+        result = SMB_VFS_NEXT_SET_OFFLINE(handle, fname);
+        do_log(SMB_VFS_OP_SET_OFFLINE, result >= 0, handle, "%s",
+               smb_fname_str_do_log(fname));
         return result;
 }
@@ -2194 +2246 @@
         .fs_capabilities = smb_full_audit_fs_capabilities,
         .opendir = smb_full_audit_opendir,
+        .fdopendir = smb_full_audit_fdopendir,
         .readdir = smb_full_audit_readdir,
         .seekdir = smb_full_audit_seekdir,
@@ -2202 +2255 @@
         .closedir = smb_full_audit_closedir,
         .init_search_op = smb_full_audit_init_search_op,
-        .open = smb_full_audit_open,
+        .open_fn = smb_full_audit_open,
         .create_file = smb_full_audit_create_file,
         .close_fn = smb_full_audit_close,
@@ -2228 +2281 @@
         .ntimes = smb_full_audit_ntimes,
         .ftruncate = smb_full_audit_ftruncate,
+        .fallocate = smb_full_audit_fallocate,
         .lock = smb_full_audit_lock,
         .kernel_flock = smb_full_audit_kernel_flock,
@@ -2296 +2350 @@
         .aio_suspend = smb_full_audit_aio_suspend,
         .aio_force = smb_full_audit_aio_force,
+        .is_offline = smb_full_audit_is_offline,
+        .set_offline = smb_full_audit_set_offline,
 };
 

trunk/server/source3/modules/vfs_gpfs.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "librpc/gen_ndr/ndr_xattr.h"
+#include "include/smbprofile.h"
 
 #undef DBGC_CLASS
@@ -30 +33 @@
 #include "nfs4_acls.h"
 #include "vfs_gpfs.h"
+#include "system/filesys.h"
 
 struct gpfs_config_data {
         bool sharemodes;
         bool leases;
+        bool hsm;
 };
 
@@ -117 +122 @@
         char real_pathname[PATH_MAX+1];
         int buflen;
+        bool mangled;
+
+        mangled = mangle_is_mangled(name, handle->conn->params);
+        if (mangled) {
+                return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
+                                                      mem_ctx, found_name);
+        }
 
         full_path = talloc_asprintf(talloc_tos(), "%s/%s", path, name);
@@ -323 +335 @@
 static NTSTATUS gpfsacl_fget_nt_acl(vfs_handle_struct *handle,
         files_struct *fsp, uint32 security_info,
-        SEC_DESC **ppdesc)
+        struct security_descriptor **ppdesc)
 {
         SMB4ACL_T *pacl = NULL;
@@ -345 +357 @@
 static NTSTATUS gpfsacl_get_nt_acl(vfs_handle_struct *handle,
         const char *name,
-        uint32 security_info, SEC_DESC **ppdesc)
+        uint32 security_info, struct security_descriptor **ppdesc)
 {
         SMB4ACL_T *pacl = NULL;
@@ -461 +473 @@
 }
 
-static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS gpfsacl_set_nt_acl_internal(files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 {
         struct gpfs_acl *acl;
@@ -489 +501 @@
 }
 
-static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
+static NTSTATUS gpfsacl_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
 {
         return gpfsacl_set_nt_acl_internal(fsp, security_info_sent, psd);
@@ -927 +939 @@
 static int gpfs_set_xattr(struct vfs_handle_struct *handle,  const char *path,
                            const char *name, const void *value, size_t size,  int flags){
+        struct xattr_DOSATTRIB dosattrib;
+        enum ndr_err_code ndr_err;
+        DATA_BLOB blob;
         const char *attrstr = value;
         unsigned int dosmode=0;
@@ -940 +955 @@
         }
 
-        if (size < 2 || attrstr[0] != '0' || attrstr[1] != 'x' ||
-                                sscanf(attrstr, "%x", &dosmode) != 1) {
-                        DEBUG(1,("gpfs_set_xattr: Trying to set badly formed DOSATTRIB on file %s - %s\n", path, attrstr));
-                return False;
-        }
+        blob.data = (uint8_t *)attrstr;
+        blob.length = size;
+
+        ndr_err = ndr_pull_struct_blob(&blob, talloc_tos(), &dosattrib,
+                        (ndr_pull_flags_fn_t)ndr_pull_xattr_DOSATTRIB);
+
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(1, ("gpfs_set_xattr: bad ndr decode "
+                          "from EA on file %s: Error = %s\n",
+                          path, ndr_errstr(ndr_err)));
+                return false;
+        }
+
+        if (dosattrib.version != 3) {
+                DEBUG(1, ("gpfs_set_xattr: expected dosattrib version 3, got "
+                          "%d\n", (int)dosattrib.version));
+                return false;
+        }
+        if (!(dosattrib.info.info3.valid_flags & XATTR_DOSINFO_ATTRIB)) {
+                DEBUG(10, ("gpfs_set_xattr: XATTR_DOSINFO_ATTRIB not "
+                           "valid, ignoring\n"));
+                return true;
+        }
+
+        dosmode = dosattrib.info.info3.attrib;
 
         attrs.winAttrs = 0;
-        /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. Ignore the others*/
+        /*Just map RD_ONLY, ARCHIVE, SYSTEM HIDDEN and SPARSE. Ignore the others*/
         if (dosmode & FILE_ATTRIBUTE_ARCHIVE){
                 attrs.winAttrs |= GPFS_WINATTR_ARCHIVE;
@@ -960 +995 @@
                         attrs.winAttrs |= GPFS_WINATTR_READONLY;
         }
+        if (dosmode & FILE_ATTRIBUTE_SPARSE) {
+                attrs.winAttrs |= GPFS_WINATTR_SPARSE_FILE;
+        }
 
 
@@ -984 +1022 @@
         struct gpfs_winattr attrs;
         int ret = 0;
-        ssize_t result;
 
         DEBUG(10, ("gpfs_get_xattr: %s \n",path));
@@ -1001 +1038 @@
                 }
 
-                DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: %d\n",ret));
+                DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: "
+                          "%d (%s)\n", ret, strerror(errno)));
                 return -1;
         }
@@ -1007 +1045 @@
         DEBUG(10, ("gpfs_get_xattr:Got attributes: 0x%x\n",attrs.winAttrs));
 
-        /*Just map RD_ONLY, ARCHIVE, SYSTEM and HIDDEN. Ignore the others*/
+        /*Just map RD_ONLY, ARCHIVE, SYSTEM, HIDDEN and SPARSE. Ignore the others*/
         if (attrs.winAttrs & GPFS_WINATTR_ARCHIVE){
                 dosmode |= FILE_ATTRIBUTE_ARCHIVE;
@@ -1020 +1058 @@
                 dosmode |= FILE_ATTRIBUTE_READONLY;
         }
-
-        result = snprintf(attrstr, size, "0x%x",
-                          dosmode & SAMBA_ATTRIBUTES_MASK) + 1;
-
+        if (attrs.winAttrs & GPFS_WINATTR_SPARSE_FILE) {
+                dosmode |= FILE_ATTRIBUTE_SPARSE;
+        }
+
+        snprintf(attrstr, size, "0x%2.2x",
+                 (unsigned int)(dosmode & SAMBA_ATTRIBUTES_MASK));
         DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
-        return result;
+        return 4;
 }
 
@@ -1050 +1090 @@
                 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
                 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+                smb_fname->st.vfs_private = attrs.winAttrs;
         }
         return 0;
@@ -1097 +1138 @@
                 smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
                 smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+                smb_fname->st.vfs_private = attrs.winAttrs;
         }
         return 0;
@@ -1142 +1184 @@
 }
 
+static int vfs_gpfs_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
+                                SMB_OFF_T len)
+{
+        int result;
+
+        result = smbd_gpfs_ftruncate(fsp->fh->fd, len);
+        if ((result == -1) && (errno == ENOSYS)) {
+                return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
+        }
+        return result;
+}
+
+static bool vfs_gpfs_is_offline(struct vfs_handle_struct *handle,
+                                const struct smb_filename *fname,
+                                SMB_STRUCT_STAT *sbuf)
+{
+        struct gpfs_winattr attrs;
+        char *path = NULL;
+        NTSTATUS status;
+
+        status = get_full_smb_filename(talloc_tos(), fname, &path);
+        if (!NT_STATUS_IS_OK(status)) {
+                errno = map_errno_from_nt_status(status);
+                return -1;
+        }
+
+        if (VALID_STAT(*sbuf)) {
+                attrs.winAttrs = sbuf->vfs_private;
+        } else {
+                int ret;
+                ret = get_gpfs_winattrs(path, &attrs);
+
+                if (ret == -1) {
+                        TALLOC_FREE(path);
+                        return false;
+                }
+        }
+        if ((attrs.winAttrs & GPFS_WINATTR_OFFLINE) != 0) {
+                DEBUG(10, ("%s is offline\n", path));
+                TALLOC_FREE(path);
+                return true;
+        }
+        DEBUG(10, ("%s is online\n", path));
+        TALLOC_FREE(path);
+        return SMB_VFS_NEXT_IS_OFFLINE(handle, fname, sbuf);
+}
+
+static bool vfs_gpfs_aio_force(struct vfs_handle_struct *handle,
+                               struct files_struct *fsp)
+{
+        return vfs_gpfs_is_offline(handle, fsp->fsp_name, &fsp->fsp_name->st);
+}
+
+static ssize_t vfs_gpfs_sendfile(vfs_handle_struct *handle, int tofd,
+                                 files_struct *fsp, const DATA_BLOB *hdr,
+                                 SMB_OFF_T offset, size_t n)
+{
+        if ((fsp->fsp_name->st.vfs_private & GPFS_WINATTR_OFFLINE) != 0) {
+                errno = ENOSYS;
+                return -1;
+        }
+        return SMB_VFS_NEXT_SENDFILE(handle, tofd, fsp, hdr, offset, n);
+}
+
 int vfs_gpfs_connect(struct vfs_handle_struct *handle, const char *service,
                         const char *user)
 {
         struct gpfs_config_data *config;
+
+        smbd_gpfs_lib_init();
+
         int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
 
@@ -1164 +1273 @@
                                         "leases", true);
 
+        config->hsm = lp_parm_bool(SNUM(handle->conn), "gpfs",
+                                   "hsm", false);
+
         SMB_VFS_HANDLE_SET_DATA(handle, config,
                                 NULL, struct gpfs_config_data,
@@ -1171 +1283 @@
 }
 
-
-static int vfs_gpfs_ftruncate(struct vfs_handle_struct *handle,
-                              struct files_struct *fsp,
-                              SMB_OFF_T len)
-{
-       int result;
-
-       result = smbd_gpfs_ftrunctate(fsp->fh->fd, len);
-       if ((result == -1) && (errno == ENOSYS)) {
-               return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
-       }
-       return result;
-}
+static uint32_t vfs_gpfs_capabilities(struct vfs_handle_struct *handle,
+                                      enum timestamp_set_resolution *p_ts_res)
+{
+        struct gpfs_config_data *config;
+        uint32_t next;
+
+        next = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
+
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct gpfs_config_data,
+                                return next);
+
+        if (config->hsm) {
+                next |= FILE_SUPPORTS_REMOTE_STORAGE;
+        }
+        return next;
+}
+
+static int vfs_gpfs_open(struct vfs_handle_struct *handle,
+                         struct smb_filename *smb_fname, files_struct *fsp,
+                         int flags, mode_t mode)
+{
+        if (lp_parm_bool(fsp->conn->params->service, "gpfs", "syncio",
+                         false)) {
+                flags |= O_SYNC;
+        }
+        return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
+}
+
 
 static struct vfs_fn_pointers vfs_gpfs_fns = {
         .connect_fn = vfs_gpfs_connect,
+        .fs_capabilities = vfs_gpfs_capabilities,
         .kernel_flock = vfs_gpfs_kernel_flock,
         .linux_setlease = vfs_gpfs_setlease,
@@ -1207 +1336 @@
         .lstat = vfs_gpfs_lstat,
         .ntimes = vfs_gpfs_ntimes,
-        .ftruncate = vfs_gpfs_ftruncate,
+        .is_offline = vfs_gpfs_is_offline,
+        .aio_force = vfs_gpfs_aio_force,
+        .sendfile = vfs_gpfs_sendfile,
+        .open_fn = vfs_gpfs_open,
+        .ftruncate = vfs_gpfs_ftruncate
 };
 

trunk/server/source3/modules/vfs_gpfs.h

@@ -35 +35 @@
 int get_gpfs_winattrs(char * pathname,struct gpfs_winattr *attrs);
 int set_gpfs_winattrs(char * pathname,int flags,struct gpfs_winattr *attrs);
-int smbd_gpfs_ftrunctate(int fd, gpfs_off64_t length);
+int smbd_gpfs_ftruncate(int fd, gpfs_off64_t length);
 void init_gpfs(void);
+void smbd_gpfs_lib_init();

trunk/server/source3/modules/vfs_hpuxacl.c

@@ -48 +48 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "modules/vfs_hpuxacl.h"
+
 
 /* 
@@ -190 +194 @@
         /* For all I see, the info should already be in the fsp
          * parameter, but get it again to be safe --- necessary? */
-        files_struct *file_struct_p = file_find_fd(fsp->fh->fd);
+        files_struct *file_struct_p = file_find_fd(fsp->conn->sconn,
+                                                   fsp->fh->fd);
         if (file_struct_p == NULL) {
                 errno = EBADF;
@@ -329 +334 @@
         /* For all I see, the info should already be in the fsp
          * parameter, but get it again to be safe --- necessary? */
-        files_struct *file_struct_p = file_find_fd(fsp->fh->fd);
+        files_struct *file_struct_p = file_find_fd(fsp->conn->sconn,
+                                                   fsp->fh->fd);
         if (file_struct_p == NULL) {
                 errno = EBADF;

trunk/server/source3/modules/vfs_irixacl.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "modules/vfs_irixacl.h"
+
 
 /* prototypes for private functions first - for clarity */

trunk/server/source3/modules/vfs_netatalk.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
 
 #undef DBGC_CLASS
@@ -199 +201 @@
 }
 
+static SMB_STRUCT_DIR *atalk_fdopendir(struct vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attr)
+{
+        SMB_STRUCT_DIR *ret = 0;
+
+        ret = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
+
+        if (ret == NULL) {
+                return ret;
+        }
+
+        /*
+         * when we try to perform delete operation upon file which has fork
+         * in ./.AppleDouble and this directory wasn't hidden by Samba,
+         * MS Windows explorer causes the error: "Cannot find the specified file"
+         * There is some workaround to avoid this situation, i.e. if
+         * connection has not .AppleDouble entry in either veto or hide 
+         * list then it would be nice to add one.
+         */
+
+        atalk_add_to_list(&handle->conn->hide_list);
+        atalk_add_to_list(&handle->conn->veto_list);
+
+        return ret;
+}
+
 static int atalk_rmdir(struct vfs_handle_struct *handle, const char *path)
 {
@@ -433 +460 @@
 static struct vfs_fn_pointers vfs_netatalk_fns = {
         .opendir = atalk_opendir,
+        .fdopendir = atalk_fdopendir,
         .rmdir = atalk_rmdir,
         .rename = atalk_rename,

trunk/server/source3/modules/vfs_notify_fam.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "librpc/gen_ndr/notify.h"
 
 #include <fam.h>
@@ -80 +82 @@
         FAMCONNECTION_GETFD(fam_conn) = -1;
 
+
+#ifdef HAVE_FAMNOEXISTS
+        /* We should honor outside setting of the GAM_CLIENT_ID. */
+        setenv("GAM_CLIENT_ID","SAMBA",0);
+#endif
+
         if (asprintf(&name, "smbd (%lu)", (unsigned long)sys_getpid()) == -1) {
                 DEBUG(0, ("No memory\n"));
@@ -86 +94 @@
 
         res = FAMOpen2(fam_conn, name);
+
+#ifdef HAVE_FAMNOEXISTS
+        /*
+         * This reduces the chatter between GAMIN and samba making the pair
+         * much more reliable.
+         */
+        FAMNoExists(fam_conn);
+#endif
+
         SAFE_FREE(name);
 

trunk/server/source3/modules/vfs_onefs.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs.h"
 #include "onefs_config.h"
@@ -265 +266 @@
         .closedir = onefs_closedir,
         .init_search_op = onefs_init_search_op,
-        .open = onefs_open,
+        .open_fn = onefs_open,
         .create_file = onefs_create_file,
         .close_fn = onefs_close,

trunk/server/source3/modules/vfs_onefs_shadow_copy.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "onefs_shadow_copy.h"
 
@@ -234 +235 @@
                               uint32_t oplock_request,
                               uint64_t allocation_size,
+                              uint32_t private_flags,
                               struct security_descriptor *sd,
                               struct ea_list *ea_list,
@@ -244 +246 @@
                                   create_disposition, create_options,
                                   file_attributes, oplock_request,
-                                  allocation_size, sd, ea_list, result, pinfo),
+                                  allocation_size, private_flags,
+                                  sd, ea_list, result, pinfo),
                               NTSTATUS);
 }
@@ -470 +473 @@
 
 static char *
-onefs_shadow_copy_realpath(vfs_handle_struct *handle, const char *path,
-                           char *resolved_path)
+onefs_shadow_copy_realpath(vfs_handle_struct *handle, const char *path)
 {
         SHADOW_NEXT(REALPATH,
-                    (handle, cpath ?: path, resolved_path),
+                    (handle, cpath ?: path),
                     char *);
 }
@@ -634 +636 @@
 static bool
 onefs_shadow_copy_is_offline(struct vfs_handle_struct *handle,
-                             const char *path, SMB_STRUCT_STAT *sbuf)
-{
+                             const struct smb_fname *fname,
+                             SMB_STRUCT_STAT *sbuf)
+{
+#error Isilon, please convert "char *path" to "struct smb_fname *fname"
         SHADOW_NEXT(IS_OFFLINE,
                     (handle, cpath ?: path, sbuf),
@@ -643 +647 @@
 static int
 onefs_shadow_copy_set_offline(struct vfs_handle_struct *handle,
-                              const char *path)
-{
+                               const struct smb_filename *fname)
+{
+#error Isilon, please convert "char *path" to "struct smb_fname *fname"
         SHADOW_NEXT(SET_OFFLINE,
                     (handle, cpath ?: path),
@@ -659 +664 @@
         .mkdir = onefs_shadow_copy_mkdir,
         .rmdir = onefs_shadow_copy_rmdir,
-        .open = onefs_shadow_copy_open,
+        .open_fn = onefs_shadow_copy_open,
         .create_file = onefs_shadow_copy_create_file,
         .rename = onefs_shadow_copy_rename,

trunk/server/source3/modules/vfs_posixacl.c

@@ -19 +19 @@
 
 #include "includes.h"
-
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "modules/vfs_posixacl.h"
 
 /* prototypes for static functions first - for clarity */

trunk/server/source3/modules/vfs_prealloc.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 /* Extent preallocation module.
@@ -214 +215 @@
 
 static struct vfs_fn_pointers prealloc_fns = {
-        .open = prealloc_open,
+        .open_fn = prealloc_open,
         .ftruncate = prealloc_ftruncate,
         .connect_fn = prealloc_connect,

trunk/server/source3/modules/vfs_preopen.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 struct preopen_state;
@@ -442 +444 @@
 
 static struct vfs_fn_pointers vfs_preopen_fns = {
-        .open = preopen_open
+        .open_fn = preopen_open
 };
 

trunk/server/source3/modules/vfs_readahead.c

@@ -17 +17 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+
+#if defined(HAVE_LINUX_READAHEAD) && ! defined(HAVE_READAHEAD_DECL)
+ssize_t readahead(int fd, off64_t offset, size_t count);
+#endif
 
 struct readahead_data {

trunk/server/source3/modules/vfs_readonly.c

@@ -22 +22 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 #include "getdate.h"
 
@@ -84 +85 @@
         struct vuid_cache_entry *ent = ent = &conn->vuid_cache.array[i];
         ent->vuid = UID_FIELD_INVALID;
-        TALLOC_FREE(ent->server_info);
+        TALLOC_FREE(ent->session_info);
         ent->read_only = false;
-        ent->admin_user = false;
       }
       conn->vuid_cache.next_entry = 0;

trunk/server/source3/modules/vfs_recycle.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "auth.h"
 
 #define ALLOC_CHECK(ptr, label) do { if ((ptr) == NULL) { DEBUG(0, ("recycle.bin: out of memory!\n")); errno = ENOMEM; goto label; } } while(0)
@@ -62 +66 @@
 {
         const char *tmp_str = NULL;
-        
 
         tmp_str = lp_parm_const_string(SNUM(handle->conn), "recycle", "repository",".recycle");
 
         DEBUG(10, ("recycle: repository = %s\n", tmp_str));
-        
+
         return tmp_str;
 }
@@ -74 +77 @@
 {
         bool ret;
-        
+
         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "keeptree", False);
 
         DEBUG(10, ("recycle_bin: keeptree = %s\n", ret?"True":"False"));
-        
+
         return ret;
 }
@@ -89 +92 @@
 
         DEBUG(10, ("recycle: versions = %s\n", ret?"True":"False"));
-        
+
         return ret;
 }
@@ -100 +103 @@
 
         DEBUG(10, ("recycle: touch = %s\n", ret?"True":"False"));
-        
+
         return ret;
 }
@@ -111 +114 @@
 
         DEBUG(10, ("recycle: touch_mtime = %s\n", ret?"True":"False"));
-        
+
         return ret;
 }
@@ -118 +121 @@
 {
         const char **tmp_lp;
-        
+
         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude", NULL);
 
         DEBUG(10, ("recycle: exclude = %s ...\n", tmp_lp?*tmp_lp:""));
-        
+
         return tmp_lp;
 }
@@ -129 +132 @@
 {
         const char **tmp_lp;
-        
+
         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude_dir", NULL);
 
         DEBUG(10, ("recycle: exclude_dir = %s ...\n", tmp_lp?*tmp_lp:""));
-        
+
         return tmp_lp;
 }
@@ -140 +143 @@
 {
         const char **tmp_lp;
-        
+
         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "noversions", NULL);
 
         DEBUG(10, ("recycle: noversions = %s\n", tmp_lp?*tmp_lp:""));
-        
+
         return tmp_lp;
 }
@@ -151 +154 @@
 {
         SMB_OFF_T maxsize;
-        
+
         maxsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
                                             "recycle", "maxsize", NULL));
 
         DEBUG(10, ("recycle: maxsize = %lu\n", (long unsigned int)maxsize));
-        
+
         return maxsize;
 }
@@ -163 +166 @@
 {
         SMB_OFF_T minsize;
-        
+
         minsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
                                             "recycle", "minsize", NULL));
 
         DEBUG(10, ("recycle: minsize = %lu\n", (long unsigned int)minsize));
-        
+
         return minsize;
 }
@@ -465 +468 @@
 
         repository = talloc_sub_advanced(NULL, lp_servicename(SNUM(conn)),
-                                        conn->server_info->unix_name,
+                                        conn->session_info->unix_name,
                                         conn->connectpath,
-                                        conn->server_info->utok.gid,
-                                        conn->server_info->sanitized_username,
-                                        pdb_get_domain(conn->server_info->sam_account),
+                                        conn->session_info->utok.gid,
+                                        conn->session_info->sanitized_username,
+                                        conn->session_info->info3->base.domain.string,
                                         recycle_repository(handle));
         ALLOC_CHECK(repository, done);
@@ -475 +478 @@
         /* Yes :-). JRA. */
         trim_char(repository, '\0', '/');
-        
+
         if(!repository || *(repository) == '\0') {
                 DEBUG(3, ("recycle: repository path not set, purging %s...\n",
@@ -674 +677 @@
         if (!NT_STATUS_IS_OK(ret))
                 return ret;
-        
+
         vfs_recycle_debug_level = debug_add_class("recycle");
         if (vfs_recycle_debug_level == -1) {
@@ -682 +685 @@
                 DEBUG(10, ("vfs_recycle: Debug class number of 'recycle': %d\n", vfs_recycle_debug_level));
         }
-        
+
         return ret;
 }

trunk/server/source3/modules/vfs_scannedonly.c

@@ -2 +2 @@
  * scannedonly VFS module for Samba 3.5
  *
- * Copyright 2007,2008,2009 (C) Olivier Sessink
+ * Copyright 2007,2008,2009,2010 (C) Olivier Sessink
  *
  * This program is free software; you can redistribute it and/or modify
@@ -49 +49 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
 
 #include "config.h"
@@ -378 +380 @@
         TALLOC_CTX *ctx=talloc_tos();
         char *cachefile;
-        int retval;
+        int retval = -1;
         int didloop;
         DEBUG(SCANNEDONLY_DEBUG,
@@ -477 +479 @@
                 while (retval != 0      /*&& errno == ENOENT */
                        && i < recheck_tries) {
-                        struct timespec req = { 0, recheck_time * 10000 };
                         DEBUG(SCANNEDONLY_DEBUG,
                               ("scannedonly_allow_access, wait (try=%d "
@@ -483 +484 @@
                                i, recheck_tries,
                                recheck_time, cache_smb_fname->base_name));
-                        nanosleep(&req, NULL);
+                        smb_msleep(recheck_time);
                         retval = SMB_VFS_NEXT_STAT(handle, cache_smb_fname);
                         i++;
@@ -527 +528 @@
         return (SMB_STRUCT_DIR *) sDIR;
 }
+
+static SMB_STRUCT_DIR *scannedonly_fdopendir(vfs_handle_struct * handle,
+                                           files_struct *fsp,
+                                           const char *mask, uint32 attr)
+{
+        SMB_STRUCT_DIR *DIRp;
+        struct scannedonly_DIR *sDIR;
+        const char *fname;
+
+        DIRp = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
+        if (!DIRp) {
+                return NULL;
+        }
+
+        fname = (const char *)fsp->fsp_name->base_name;
+
+        sDIR = TALLOC_P(NULL, struct scannedonly_DIR);
+        if (fname[0] != '/') {
+                sDIR->base = construct_full_path(sDIR,handle, fname, true);
+        } else {
+                sDIR->base = name_w_ending_slash(sDIR, fname);
+        }
+        DEBUG(SCANNEDONLY_DEBUG,
+                        ("scannedonly_fdopendir, fname=%s, base=%s\n",fname,sDIR->base));
+        sDIR->DIR = DIRp;
+        sDIR->notify_loop_done = 0;
+        return (SMB_STRUCT_DIR *) sDIR;
+}
+
 
 static SMB_STRUCT_DIRENT *scannedonly_readdir(vfs_handle_struct *handle,
@@ -767 +797 @@
         struct smb_filename *smb_fname_dst_tmp = NULL;
         char *cachefile_src, *cachefile_dst;
+        bool needscandst=false;
+        int ret;
         TALLOC_CTX *ctx = talloc_tos();
 
@@ -778 +810 @@
                 smb_fname_dst->base_name,
                 STRUCTSCANO(handle->data)->p_scanned);
-
         create_synthetic_smb_fname(ctx, cachefile_src,NULL,NULL,
                                    &smb_fname_src_tmp);
@@ -784 +815 @@
                                    &smb_fname_dst_tmp);
 
-        if (SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp, smb_fname_dst_tmp)
-            != 0) {
+        ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp, smb_fname_dst_tmp);
+        if (ret == ENOENT) {
+                needscandst=true;
+        } else if (ret != 0) {
                 DEBUG(SCANNEDONLY_DEBUG,
-                      ("failed to rename %s into %s\n", cachefile_src,
-                       cachefile_dst));
-        }
-        return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
+                      ("failed to rename %s into %s error %d: %s\n", cachefile_src,
+                       cachefile_dst, ret, strerror(ret)));
+                needscandst=true;
+        }
+        ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
+        if (ret == 0 && needscandst) {
+                notify_scanner(handle, smb_fname_dst->base_name);
+                flush_sendbuffer(handle);
+        }
+        return ret;
 }
 
@@ -979 +1018 @@
 static struct vfs_fn_pointers vfs_scannedonly_fns = {
         .opendir = scannedonly_opendir,
+        .fdopendir = scannedonly_fdopendir,
         .readdir = scannedonly_readdir,
         .seekdir = scannedonly_seekdir,
@@ -987 +1027 @@
         .stat = scannedonly_stat,
         .lstat = scannedonly_lstat,
-        .open = scannedonly_open,
+        .open_fn = scannedonly_open,
         .close_fn = scannedonly_close,
         .rename = scannedonly_rename,

trunk/server/source3/modules/vfs_shadow_copy.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "ntioctl.h"
 
 /*
@@ -119 +121 @@
 }
 
+static SMB_STRUCT_DIR *shadow_copy_fdopendir(vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attr)
+{
+        shadow_copy_Dir *dirp;
+        SMB_STRUCT_DIR *p = SMB_VFS_NEXT_FDOPENDIR(handle,fsp,mask,attr);
+
+        if (!p) {
+                DEBUG(10,("shadow_copy_opendir: SMB_VFS_NEXT_FDOPENDIR() failed for [%s]\n",
+                        smb_fname_str_dbg(fsp->fsp_name)));
+                return NULL;
+        }
+
+        dirp = SMB_MALLOC_P(shadow_copy_Dir);
+        if (!dirp) {
+                DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
+                SMB_VFS_NEXT_CLOSEDIR(handle,p);
+                /* We have now closed the fd in fsp. */
+                fsp->fh->fd = -1;
+                return NULL;
+        }
+
+        ZERO_STRUCTP(dirp);
+
+        while (True) {
+                SMB_STRUCT_DIRENT *d;
+
+                d = SMB_VFS_NEXT_READDIR(handle, p, NULL);
+                if (d == NULL) {
+                        break;
+                }
+
+                if (shadow_copy_match_name(d->d_name)) {
+                        DEBUG(8,("shadow_copy_fdopendir: hide [%s]\n",d->d_name));
+                        continue;
+                }
+
+                DEBUG(10,("shadow_copy_fdopendir: not hide [%s]\n",d->d_name));
+
+                dirp->dirs = SMB_REALLOC_ARRAY(dirp->dirs,SMB_STRUCT_DIRENT, dirp->num+1);
+                if (!dirp->dirs) {
+                        DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
+                        break;
+                }
+
+                dirp->dirs[dirp->num++] = *d;
+        }
+
+        SMB_VFS_NEXT_CLOSEDIR(handle,p);
+        /* We have now closed the fd in fsp. */
+        fsp->fh->fd = -1;
+        return((SMB_STRUCT_DIR *)dirp);
+}
+
 static SMB_STRUCT_DIRENT *shadow_copy_readdir(vfs_handle_struct *handle,
                                               SMB_STRUCT_DIR *_dirp,
@@ -163 +217 @@
 }
 
-static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle, files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, bool labels)
+static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
+                                            files_struct *fsp,
+                                            struct shadow_copy_data *shadow_copy_data,
+                                            bool labels)
 {
         SMB_STRUCT_DIR *p = SMB_VFS_NEXT_OPENDIR(handle,fsp->conn->connectpath,NULL,0);
@@ -197 +254 @@
                 }
 
-                tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data->mem_ctx,
+                tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data,
                                                                         shadow_copy_data->labels,
                                                                         (shadow_copy_data->num_volumes+1)*sizeof(SHADOW_COPY_LABEL));
@@ -217 +274 @@
 static struct vfs_fn_pointers vfs_shadow_copy_fns = {
         .opendir = shadow_copy_opendir,
+        .fdopendir = shadow_copy_fdopendir,
         .readdir = shadow_copy_readdir,
         .seekdir = shadow_copy_seekdir,

trunk/server/source3/modules/vfs_shadow_copy2.c

@@ -3 +3 @@
  *
  * Copyright (C) Andrew Tridgell     2007
+ * Copyright (C) Ed Plese            2009
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "ntioctl.h"
 
 /*
@@ -34 +38 @@
      from the original. This allows the 'restore' button to work
      without a sharing violation
+
+     3) shadow copy results can be sorted before being sent to the
+     client.  This is beneficial for filesystems that don't read
+     directories alphabetically (the default unix).
+
+     4) vanity naming for snapshots. Snapshots can be named in any
+     format compatible with str[fp]time conversions.
+
+     5) time stamps in snapshot names can be represented in localtime
+     rather than UTC.
 
   Module options:
@@ -59 +73 @@
       copy UI will fail with a sharing violation.
 
-  Note that the directory names in the snapshot directory must take the form
-  @GMT-YYYY.MM.DD-HH.MM.SS
-  
-  The following command would generate a correctly formatted directory name:
+      shadow:sort = asc/desc, or not specified for unsorted (default)
+
+      This is an optional parameter that specifies that the shadow
+      copy directories should be sorted before sending them to the
+      client.  This can be beneficial as unix filesystems are usually
+      not listed alphabetically sorted.  If enabled, you typically
+      want to specify descending order.
+
+      shadow:format = <format specification for snapshot names>
+
+      This is an optional parameter that specifies the format
+      specification for the naming of snapshots.  The format must
+      be compatible with the conversion specifications recognized
+      by str[fp]time.  The default value is "@GMT-%Y.%m.%d-%H.%M.%S".
+
+      shadow:localtime = yes/no (default is no)
+
+      This is an optional parameter that indicates whether the
+      snapshot names are in UTC/GMT or the local time.
+
+
+  The following command would generate a correctly formatted directory name
+  for use with the default parameters:
      date -u +@GMT-%Y.%m.%d-%H.%M.%S
   
@@ -73 +106 @@
 
 #define GMT_NAME_LEN 24 /* length of a @GMT- name */
+#define SHADOW_COPY2_GMT_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
+
+#define SHADOW_COPY2_DEFAULT_SORT NULL
+#define SHADOW_COPY2_DEFAULT_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
+#define SHADOW_COPY2_DEFAULT_LOCALTIME false
 
 /*
@@ -98 +136 @@
         }
         return True;
+}
+
+static char *shadow_copy2_snapshot_to_gmt(TALLOC_CTX *mem_ctx,
+                                vfs_handle_struct *handle, const char *name)
+{
+        struct tm timestamp;
+        time_t timestamp_t;
+        char gmt[GMT_NAME_LEN + 1];
+        const char *fmt;
+
+        fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
+                                   "format", SHADOW_COPY2_DEFAULT_FORMAT);
+
+        ZERO_STRUCT(timestamp);
+        if (strptime(name, fmt, &timestamp) == NULL) {
+                DEBUG(10, ("shadow_copy2_snapshot_to_gmt: no match %s: %s\n",
+                           fmt, name));
+                return NULL;
+        }
+
+        DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n", fmt, name));
+        if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime",
+                         SHADOW_COPY2_DEFAULT_LOCALTIME))
+        {
+                timestamp.tm_isdst = -1;
+                timestamp_t = mktime(&timestamp);
+                gmtime_r(&timestamp_t, &timestamp);
+        }
+        strftime(gmt, sizeof(gmt), SHADOW_COPY2_GMT_FORMAT, &timestamp);
+
+        return talloc_strdup(mem_ctx, gmt);
 }
 
@@ -185 +254 @@
 
 #define _SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret, extra) do { \
-                const char *gmt_start; \
-                if (shadow_copy2_match_name(smb_fname->base_name, &gmt_start)) {        \
+        const char *gmt_start; \
+        if (shadow_copy2_match_name(smb_fname->base_name, &gmt_start)) { \
                 char *name2; \
                 char *smb_base_name_tmp = NULL; \
@@ -346 +415 @@
         const char *snapdir, *relpath, *baseoffset, *basedir;
         size_t baselen;
-        char *ret;
+        char *ret, *prefix;
+
+        struct tm timestamp;
+        time_t timestamp_t;
+        char snapshot[MAXPATHLEN];
+        const char *fmt;
+
+        fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
+                                   "format", SHADOW_COPY2_DEFAULT_FORMAT);
 
         snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
@@ -360 +437 @@
                 talloc_free(tmp_ctx);
                 return NULL;
+        }
+
+        prefix = talloc_asprintf(tmp_ctx, "%s/@GMT-", snapdir);
+        if (strncmp(fname, prefix, (talloc_get_size(prefix)-1)) == 0) {
+                /* this looks like as we have already normalized it, leave it untouched*/
+                talloc_free(tmp_ctx);
+                return talloc_strdup(handle->data, fname);
         }
 
@@ -370 +454 @@
         }
 
-        relpath = fname + GMT_NAME_LEN;
+        ZERO_STRUCT(timestamp);
+        relpath = strptime(fname, SHADOW_COPY2_GMT_FORMAT, &timestamp);
+        if (relpath == NULL) {
+                talloc_free(tmp_ctx);
+                return NULL;
+        }
+
+        /* relpath is the remaining portion of the path after the @GMT-xxx */
+
+        if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime",
+                         SHADOW_COPY2_DEFAULT_LOCALTIME))
+        {
+                timestamp_t = timegm(&timestamp);
+                localtime_r(&timestamp_t, &timestamp);
+        }
+
+        strftime(snapshot, MAXPATHLEN, fmt, &timestamp);
+
         baselen = strlen(basedir);
         baseoffset = handle->conn->connectpath + baselen;
@@ -386 +487 @@
         if (*baseoffset == '/') baseoffset++;
 
-        ret = talloc_asprintf(handle->data, "%s/%.*s/%s/%s", 
+        ret = talloc_asprintf(handle->data, "%s/%s/%s/%s",
                               snapdir, 
-                              GMT_NAME_LEN, fname, 
+                              snapshot,
                               baseoffset, 
                               relpath);
@@ -438 +539 @@
                                const struct smb_filename *smb_fname_dst)
 {
+        if (shadow_copy2_match_name(smb_fname_src->base_name, NULL)) {
+                errno = EXDEV;
+                return -1;
+        }
         SHADOW2_NEXT2_SMB_FNAME(RENAME,
                                 (handle, smb_fname_src, smb_fname_dst));
@@ -556 +661 @@
 
 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
-                            const char *fname, char *resolved_path)
+                            const char *fname)
 {
         const char *gmt;
@@ -562 +667 @@
         if (shadow_copy2_match_name(fname, &gmt)
             && (gmt[GMT_NAME_LEN] == '\0')) {
-                char *copy, *result;
+                char *copy;
 
                 copy = talloc_strdup(talloc_tos(), fname);
@@ -571 +676 @@
 
                 copy[gmt - fname] = '.';
+                copy[gmt - fname + 1] = '\0';
 
                 DEBUG(10, ("calling NEXT_REALPATH with %s\n", copy));
-                result = SMB_VFS_NEXT_REALPATH(handle, copy, resolved_path);
-                TALLOC_FREE(copy);
-                return result;
-        }
-        SHADOW2_NEXT(REALPATH, (handle, name, resolved_path), char *, NULL);
+                SHADOW2_NEXT(REALPATH, (handle, name), char *,
+                             NULL);
+        }
+        SHADOW2_NEXT(REALPATH, (handle, name), char *, NULL);
 }
 
@@ -719 +824 @@
 }
 
+static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
+{
+        return strncmp((char *)x, (char *)y, sizeof(SHADOW_COPY_LABEL));
+}
+
+static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
+{
+        return -strncmp((char *)x, (char *)y, sizeof(SHADOW_COPY_LABEL));
+}
+
+/*
+  sort the shadow copy data in ascending or descending order
+ */
+static void shadow_copy2_sort_data(vfs_handle_struct *handle,
+                                   struct shadow_copy_data *shadow_copy2_data)
+{
+        int (*cmpfunc)(const void *, const void *);
+        const char *sort;
+
+        sort = lp_parm_const_string(SNUM(handle->conn), "shadow",
+                                    "sort", SHADOW_COPY2_DEFAULT_SORT);
+        if (sort == NULL) {
+                return;
+        }
+
+        if (strcmp(sort, "asc") == 0) {
+                cmpfunc = shadow_copy2_label_cmp_asc;
+        } else if (strcmp(sort, "desc") == 0) {
+                cmpfunc = shadow_copy2_label_cmp_desc;
+        } else {
+                return;
+        }
+
+        if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
+            shadow_copy2_data->labels)
+        {
+                TYPESAFE_QSORT(shadow_copy2_data->labels,
+                               shadow_copy2_data->num_volumes,
+                               cmpfunc);
+        }
+
+        return;
+}
+
 static int shadow_copy2_get_shadow_copy2_data(vfs_handle_struct *handle, 
                                               files_struct *fsp, 
-                                              SHADOW_COPY_DATA *shadow_copy2_data, 
+                                              struct shadow_copy_data *shadow_copy2_data,
                                               bool labels)
 {
@@ -728 +877 @@
         SMB_STRUCT_DIRENT *d;
         TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
+        char *snapshot;
 
         snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
@@ -748 +898 @@
         }
 
-        talloc_free(tmp_ctx);
-
         shadow_copy2_data->num_volumes = 0;
         shadow_copy2_data->labels      = NULL;
@@ -757 +905 @@
 
                 /* ignore names not of the right form in the snapshot directory */
-                if (!shadow_copy2_match_name(d->d_name, NULL)) {
+                snapshot = shadow_copy2_snapshot_to_gmt(tmp_ctx, handle,
+                                                        d->d_name);
+                DEBUG(6,("shadow_copy2_get_shadow_copy2_data: %s -> %s\n",
+                         d->d_name, snapshot));
+                if (!snapshot) {
                         continue;
                 }
@@ -767 +919 @@
                 }
 
-                tlabels = talloc_realloc(shadow_copy2_data->mem_ctx,
+                tlabels = talloc_realloc(shadow_copy2_data,
                                          shadow_copy2_data->labels,
                                          SHADOW_COPY_LABEL, shadow_copy2_data->num_volumes+1);
@@ -773 +925 @@
                         DEBUG(0,("shadow_copy2: out of memory\n"));
                         SMB_VFS_NEXT_CLOSEDIR(handle, p);
+                        talloc_free(tmp_ctx);
                         return -1;
                 }
 
-                strlcpy(tlabels[shadow_copy2_data->num_volumes], d->d_name, sizeof(*tlabels));
+                strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
+                        sizeof(*tlabels));
+                talloc_free(snapshot);
+
                 shadow_copy2_data->num_volumes++;
                 shadow_copy2_data->labels = tlabels;
@@ -782 +938 @@
 
         SMB_VFS_NEXT_CLOSEDIR(handle,p);
+
+        shadow_copy2_sort_data(handle, shadow_copy2_data);
+
+        talloc_free(tmp_ctx);
         return 0;
 }
@@ -797 +957 @@
         .setxattr = shadow_copy2_setxattr,
         .lsetxattr = shadow_copy2_lsetxattr,
-        .open = shadow_copy2_open,
+        .open_fn = shadow_copy2_open,
         .rename = shadow_copy2_rename,
         .stat = shadow_copy2_stat,

trunk/server/source3/modules/vfs_smb_traffic_analyzer.c

@@ -3 +3 @@
  * on the net.
  *
- * Copyright (C) Holger Hetterich, 2008
+ * Copyright (C) Holger Hetterich, 2008-2010
  * Copyright (C) Jeremy Allison, 2008
  *
@@ -21 +21 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "../smbd/globals.h"
+#include "../lib/crypto/crypto.h"
+#include "vfs_smb_traffic_analyzer.h"
+#include "../libcli/security/security.h"
+#include "secrets.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "auth.h"
 
 /* abstraction for the send_over_network function */
-
 enum sock_type {INTERNET_SOCKET = 0, UNIX_DOMAIN_SOCKET};
 
@@ -45 +52 @@
 
 /* Connect to an internet socket */
-
 static int smb_traffic_analyzer_connect_inet_socket(vfs_handle_struct *handle,
                                         const char *name, uint16_t port)
@@ -109 +115 @@
 
 /* Connect to a unix domain socket */
-
 static int smb_traffic_analyzer_connect_unix_socket(vfs_handle_struct *handle,
                                                 const char *name)
@@ -142 +147 @@
 
 /* Private data allowing shared connection sockets. */
-
 struct refcounted_sock {
         struct refcounted_sock *next, *prev;
@@ -151 +155 @@
 };
 
-/* Send data over a socket */
+
+/**
+ * Encryption of a data block with AES
+ * TALLOC_CTX *ctx      Talloc context to work on
+ * const char *akey     128bit key for the encryption
+ * const char *str      Data buffer to encrypt, \0 terminated
+ * int *len             Will be set to the length of the
+ *                      resulting data block
+ * The caller has to take care for the memory
+ * allocated on the context.
+ */
+static char *smb_traffic_analyzer_encrypt( TALLOC_CTX *ctx,
+        const char *akey, const char *str, size_t *len)
+{
+        int s1,s2,h,d;
+        AES_KEY key;
+        unsigned char filler[17]= "................";
+        char *output;
+        unsigned char crypted[18];
+        if (akey == NULL) return NULL;
+        samba_AES_set_encrypt_key((unsigned char *) akey, 128, &key);
+        s1 = strlen(str) / 16;
+        s2 = strlen(str) % 16;
+        for (h = 0; h < s2; h++) *(filler+h)=*(str+(s1*16)+h);
+        DEBUG(10, ("smb_traffic_analyzer_send_data_socket: created %s"
+                " as filling block.\n", filler));
+        output = talloc_array(ctx, char, (s1*16)+17 );
+        d=0;
+        for (h = 0; h < s1; h++) {
+                samba_AES_encrypt((unsigned char *) str+(16*h), crypted, &key);
+                for (d = 0; d<16; d++) output[d+(16*h)]=crypted[d];
+        }
+        samba_AES_encrypt( (unsigned char *) str+(16*h), filler, &key );
+        for (d = 0;d < 16; d++) output[d+(16*h)]=*(filler+d);
+        *len = (s1*16)+16;
+        return output;  
+}
+
+/**
+ * Create a v2 header.
+ * TALLLOC_CTX *ctx             Talloc context to work on
+ * const char *state_flags      State flag string
+ * int len                      length of the data block
+ */
+static char *smb_traffic_analyzer_create_header( TALLOC_CTX *ctx,
+        const char *state_flags, size_t data_len)
+{
+        char *header = talloc_asprintf( ctx, "V2.%s%017u",
+                                        state_flags, (unsigned int) data_len);
+        DEBUG(10, ("smb_traffic_analyzer_send_data_socket: created Header:\n"));
+        dump_data(10, (uint8_t *)header, strlen(header));
+        return header;
+}
+
+
+/**
+ * Actually send header and data over the network
+ * char *header         Header data
+ * char *data           Data Block
+ * int dlength          Length of data block
+ * int socket
+ */
+static void smb_traffic_analyzer_write_data( char *header, char *data,
+                        int dlength, int _socket)
+{
+                int len = strlen(header);
+                if (write_data( _socket, header, len) != len) {
+                        DEBUG(1, ("smb_traffic_analyzer_send_data_socket: "
+                                                "error sending the header"
+                                                " over the socket!\n"));
+                }
+                DEBUG(10,("smb_traffic_analyzer_write_data: sending data:\n"));
+                dump_data( 10, (uint8_t *)data, dlength);
+
+                if (write_data( _socket, data, dlength) != dlength) {
+                        DEBUG(1, ("smb_traffic_analyzer_write_data: "
+                                "error sending crypted data to socket!\n"));
+                }
+}
+
+
+/*
+ * Anonymize a string if required.
+ * TALLOC_CTX *ctx                      The talloc context to work on
+ * const char *str                      The string to anonymize
+ * vfs_handle_struct *handle            The handle struct to work on
+ *
+ * Returns a newly allocated string, either the anonymized one,
+ * or a copy of const char *str. The caller has to take care for
+ * freeing the allocated memory.
+ */
+static char *smb_traffic_analyzer_anonymize( TALLOC_CTX *ctx,
+                                        const char *str,
+                                        vfs_handle_struct *handle )
+{
+        const char *total_anonymization;
+        const char *anon_prefix;
+        char *output;
+        total_anonymization=lp_parm_const_string(SNUM(handle->conn),
+                                        "smb_traffic_analyzer",
+                                        "total_anonymization", NULL);
+
+        anon_prefix=lp_parm_const_string(SNUM(handle->conn),
+                                        "smb_traffic_analyzer",
+                                        "anonymize_prefix", NULL );
+        if (anon_prefix != NULL) {
+                if (total_anonymization != NULL) {
+                        output = talloc_asprintf(ctx, "%s",
+                                        anon_prefix);
+                } else {
+                output = talloc_asprintf(ctx, "%s%i", anon_prefix,
+                                                str_checksum(str));
+                }
+        } else {
+                output = talloc_asprintf(ctx, "%s", str);
+        }
+
+        return output;
+}
+
+
+/**
+ * The marshalling function for protocol v2.
+ * TALLOC_CTX *ctx              Talloc context to work on
+ * struct tm *tm                tm struct for the timestamp
+ * int seconds                  milliseconds of the timestamp
+ * vfs_handle_struct *handle    vfs_handle_struct
+ * char *username               Name of the user
+ * int vfs_operation            VFS operation identifier
+ * int count                    Number of the common data blocks
+ * [...] variable args          data blocks taken from the individual
+ *                              VFS data structures
+ *
+ * Returns the complete data block to send. The caller has to
+ * take care for freeing the allocated buffer.
+ */
+static char *smb_traffic_analyzer_create_string( TALLOC_CTX *ctx,
+        struct tm *tm, int seconds, vfs_handle_struct *handle, \
+        char *username, int vfs_operation, int count, ... )
+{
+        
+        va_list ap;
+        char *arg = NULL;
+        int len;
+        char *common_data_count_str = NULL;
+        char *timestr = NULL;
+        char *sidstr = NULL;
+        char *usersid = NULL;
+        char *buf = NULL;
+        char *vfs_operation_str = NULL;
+        const char *service_name = lp_const_servicename(handle->conn->params->service);
+
+        /*
+         * first create the data that is transfered with any VFS op
+         * These are, in the following order:
+         *(0) number of data to come [6 in v2.0]
+         * 1.vfs_operation identifier
+         * 2.username
+         * 3.user-SID
+         * 4.affected share
+         * 5.domain
+         * 6.timestamp
+         * 7.IP Addresss of client
+         */
+
+        /*
+         * number of common data blocks to come,
+         * this is a #define in vfs_smb_traffic_anaylzer.h,
+         * it's length is known at compile time
+         */
+        common_data_count_str = talloc_strdup( ctx, SMBTA_COMMON_DATA_COUNT);
+        /* vfs operation identifier */
+        vfs_operation_str = talloc_asprintf( common_data_count_str, "%i",
+                                                        vfs_operation);
+        /*
+         * Handle anonymization. In protocol v2, we have to anonymize
+         * both the SID and the username. The name is already
+         * anonymized if needed, by the calling function.
+         */
+        usersid = dom_sid_string( common_data_count_str,
+                &handle->conn->session_info->security_token->sids[0]);
+
+        sidstr = smb_traffic_analyzer_anonymize(
+                common_data_count_str,
+                usersid,
+                handle);
+        
+        /* time stamp */
+        timestr = talloc_asprintf( common_data_count_str, \
+                "%04d-%02d-%02d %02d:%02d:%02d.%03d", \
+                tm->tm_year+1900, \
+                tm->tm_mon+1, \
+                tm->tm_mday, \
+                tm->tm_hour, \
+                tm->tm_min, \
+                tm->tm_sec, \
+                (int)seconds);
+        len = strlen( timestr );
+        /* create the string of common data */
+        buf = talloc_asprintf(ctx,
+                "%s%04u%s%04u%s%04u%s%04u%s%04u%s%04u%s%04u%s",
+                common_data_count_str,
+                (unsigned int) strlen(vfs_operation_str),
+                vfs_operation_str,
+                (unsigned int) strlen(username),
+                username,
+                (unsigned int) strlen(sidstr),
+                sidstr,
+                (unsigned int) strlen(service_name),
+                service_name,
+                (unsigned int)
+                strlen(handle->conn->session_info->info3->base.domain.string),
+                handle->conn->session_info->info3->base.domain.string,
+                (unsigned int) strlen(timestr),
+                timestr,
+                (unsigned int) strlen(handle->conn->sconn->client_id.addr),
+                handle->conn->sconn->client_id.addr);
+
+        talloc_free(common_data_count_str);
+
+        /* data blocks depending on the VFS function */ 
+        va_start( ap, count );
+        while ( count-- ) {
+                arg = va_arg( ap, char * );
+                /*
+                 *  protocol v2 sends a four byte string
+                 * as a header to each block, including
+                 * the numbers of bytes to come in the
+                 * next string.
+                 */
+                len = strlen( arg );
+                buf = talloc_asprintf_append( buf, "%04u%s", len, arg);
+        }
+        va_end( ap );
+        return buf;
+}
 
 static void smb_traffic_analyzer_send_data(vfs_handle_struct *handle,
-                                        ssize_t result,
-                                        const char *file_name,
-                                        bool Write)
+                                        void *data,
+                                        enum vfs_id vfs_operation )
 {
         struct refcounted_sock *rf_sock = NULL;
@@ -165 +403 @@
         char *str = NULL;
         char *username = NULL;
-        const char *anon_prefix = NULL;
-        const char *total_anonymization = NULL;
+        char *header = NULL;
+        const char *protocol_version = NULL;
+        bool Write = false;
         size_t len;
+        size_t size;
+        char *akey, *output;
+
+        /*
+         * The state flags are part of the header
+         * and are descripted in the protocol description
+         * in vfs_smb_traffic_analyzer.h. They begin at byte
+         * 03 of the header.
+         */
+        char state_flags[9] = "000000\0";
+
+        /**
+         * The first byte of the state flag string represents
+         * the modules protocol subversion number, defined
+         * in smb_traffic_analyzer.h. smbtatools/smbtad are designed
+         * to handle not yet implemented protocol enhancements
+         * by ignoring them. By recognizing the SMBTA_SUBRELEASE
+         * smbtatools can tell the user to update the client
+         * software.
+         */
+        state_flags[0] = SMBTA_SUBRELEASE;
 
         SMB_VFS_HANDLE_GET_DATA(handle, rf_sock, struct refcounted_sock, return);
@@ -178 +438 @@
 
         GetTimeOfDay(&tv);
-        tv_sec = convert_timespec_to_time_t(convert_timeval_to_timespec(tv));
+        tv_sec = tv.tv_sec;
         tm = localtime(&tv_sec);
         if (!tm) {
@@ -185 +445 @@
         seconds=(float) (tv.tv_usec / 1000);
 
-        /* check if anonymization is required */
-
-        total_anonymization=lp_parm_const_string(SNUM(handle->conn),"smb_traffic_analyzer",
-                                        "total_anonymization", NULL);
-
-        anon_prefix=lp_parm_const_string(SNUM(handle->conn),"smb_traffic_analyzer",\
-                                        "anonymize_prefix", NULL );
-        if (anon_prefix!=NULL) {
-                if (total_anonymization!=NULL) {
-                        username = talloc_asprintf(talloc_tos(),
-                                "%s",
-                                anon_prefix);
-                } else {
-                        username = talloc_asprintf(talloc_tos(),
-                                "%s%i",
-                                anon_prefix,
-                                str_checksum(
-                                        handle->conn->server_info->sanitized_username ) ); 
-                }
-
-        } else {
-                username = handle->conn->server_info->sanitized_username;
-        }
+        /*
+         * Check if anonymization is required, and if yes do this only for
+         * the username here, needed vor protocol version 1. In v2 we
+         * additionally anonymize the SID, which is done in it's marshalling
+         * function.
+         */
+        username = smb_traffic_analyzer_anonymize( talloc_tos(),
+                        handle->conn->session_info->sanitized_username,
+                        handle);
 
         if (!username) {
@@ -213 +459 @@
         }
 
-        str = talloc_asprintf(talloc_tos(),
+        protocol_version = lp_parm_const_string(SNUM(handle->conn),
+                                        "smb_traffic_analyzer",
+                                        "protocol_version", NULL );
+
+
+        if (protocol_version != NULL && strcmp(protocol_version,"V1") == 0) {
+
+                struct rw_data *s_data = (struct rw_data *) data;
+
+                /*
+                 * in case of protocol v1, ignore any vfs operations
+                 * except read,pread,write,pwrite, and set the "Write"
+                 * bool accordingly, send data and return.
+                 */
+                if ( vfs_operation > vfs_id_pwrite ) return;
+
+                if ( vfs_operation <= vfs_id_pread ) Write=false;
+                        else Write=true;
+
+                str = talloc_asprintf(talloc_tos(),
                         "V1,%u,\"%s\",\"%s\",\"%c\",\"%s\",\"%s\","
                         "\"%04d-%02d-%02d %02d:%02d:%02d.%03d\"\n",
-                        (unsigned int)result,
+                        (unsigned int) s_data->len,
                         username,
-                        pdb_get_domain(handle->conn->server_info->sam_account),
+                        handle->conn->session_info->info3->base.domain.string,
                         Write ? 'W' : 'R',
                         handle->conn->connectpath,
-                        file_name,
+                        s_data->filename,
                         tm->tm_year+1900,
                         tm->tm_mon+1,
@@ -229 +494 @@
                         tm->tm_sec,
                         (int)seconds);
+                len = strlen(str);
+                if (write_data(rf_sock->sock, str, len) != len) {
+                        DEBUG(1, ("smb_traffic_analyzer_send_data_socket: "
+                        "error sending V1 protocol data to socket!\n"));
+                return;
+                }
+
+        } else {
+                /**
+                 * Protocol 2 is used by default.
+                 */
+
+                switch( vfs_operation ) {
+                case vfs_id_open: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_open,
+                                3, ((struct open_data *) data)->filename,
+                                talloc_asprintf( talloc_tos(), "%u",
+                                ((struct open_data *) data)->mode),
+                                talloc_asprintf( talloc_tos(), "%u",
+                                ((struct open_data *) data)->result));
+                        break;
+                case vfs_id_close: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_close,
+                                2, ((struct close_data *) data)->filename,
+                                talloc_asprintf( talloc_tos(), "%u",
+                                ((struct close_data *) data)->result));
+                        break;
+                case vfs_id_mkdir: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_mkdir, \
+                                3, ((struct mkdir_data *) data)->path, \
+                                talloc_asprintf( talloc_tos(), "%u", \
+                                ((struct mkdir_data *) data)->mode), \
+                                talloc_asprintf( talloc_tos(), "%u", \
+                                ((struct mkdir_data *) data)->result ));
+                        break;
+                case vfs_id_rmdir: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_rmdir,
+                                2, ((struct rmdir_data *) data)->path, \
+                                talloc_asprintf( talloc_tos(), "%u", \
+                                ((struct rmdir_data *) data)->result ));
+                        break;
+                case vfs_id_rename: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_rename,
+                                3, ((struct rename_data *) data)->src, \
+                                ((struct rename_data *) data)->dst,
+                                talloc_asprintf(talloc_tos(), "%u", \
+                                ((struct rename_data *) data)->result));
+                        break;
+                case vfs_id_chdir: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_id_chdir,
+                                2, ((struct chdir_data *) data)->path, \
+                                talloc_asprintf(talloc_tos(), "%u", \
+                                ((struct chdir_data *) data)->result));
+                        break;
+
+                case vfs_id_write:
+                case vfs_id_pwrite:
+                case vfs_id_read:
+                case vfs_id_pread: ;
+                        str = smb_traffic_analyzer_create_string( talloc_tos(),
+                                tm, seconds, handle, username, vfs_operation,
+                                2, ((struct rw_data *) data)->filename, \
+                                talloc_asprintf(talloc_tos(), "%u", \
+                                (unsigned int)
+                                        ((struct rw_data *) data)->len));
+                        break;
+                default:
+                        DEBUG(1, ("smb_traffic_analyzer: error! "
+                                "wrong VFS operation id detected!\n"));
+                        return;
+                }
+
+        }
 
         if (!str) {
+                DEBUG(1, ("smb_traffic_analyzer_send_data: "
+                        "unable to create string to send!\n"));
                 return;
         }
 
-        len = strlen(str);
-
-        DEBUG(10, ("smb_traffic_analyzer_send_data_socket: sending %s\n",
-                        str));
-        if (write_data(rf_sock->sock, str, len) != len) {
-                DEBUG(1, ("smb_traffic_analyzer_send_data_socket: "
-                        "error sending data to socket!\n"));
-                return ;
-        }
+
+        /*
+         * If configured, optain the key and run AES encryption
+         * over the data.
+         */
+        become_root();
+        akey = (char *) secrets_fetch("smb_traffic_analyzer_key", &size);
+        unbecome_root();
+        if ( akey != NULL ) {
+                state_flags[2] = 'E';
+                DEBUG(10, ("smb_traffic_analyzer_send_data_socket: a key was"
+                        " found, encrypting data!\n"));
+                output = smb_traffic_analyzer_encrypt( talloc_tos(),
+                                                akey, str, &len);
+                SAFE_FREE(akey);
+                header = smb_traffic_analyzer_create_header( talloc_tos(),
+                                                state_flags, len);
+
+                DEBUG(10, ("smb_traffic_analyzer_send_data_socket:"
+                        " header created for crypted data: %s\n", header));
+                smb_traffic_analyzer_write_data(header, output, len,
+                                                        rf_sock->sock);
+                return;
+
+        }
+
+        len = strlen(str);
+        header = smb_traffic_analyzer_create_header( talloc_tos(),
+                                state_flags, len);
+        smb_traffic_analyzer_write_data(header, str, strlen(str),
+                                rf_sock->sock);
+
 }
 
@@ -337 +706 @@
 }
 
-/* VFS Functions: write, read, pread, pwrite for now */
+/* VFS Functions */
+static int smb_traffic_analyzer_chdir(vfs_handle_struct *handle, \
+                        const char *path)
+{
+        struct chdir_data s_data;
+        s_data.result = SMB_VFS_NEXT_CHDIR(handle, path);
+        s_data.path = path;
+        DEBUG(10, ("smb_traffic_analyzer_chdir: CHDIR: %s\n", path));
+        smb_traffic_analyzer_send_data(handle, &s_data, vfs_id_chdir);
+        return s_data.result;
+}
+
+static int smb_traffic_analyzer_rename(vfs_handle_struct *handle, \
+                const struct smb_filename *smb_fname_src,
+                const struct smb_filename *smb_fname_dst)
+{
+        struct rename_data s_data;
+        s_data.result = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, \
+                smb_fname_dst);
+        s_data.src = smb_fname_src->base_name;
+        s_data.dst = smb_fname_dst->base_name;
+        DEBUG(10, ("smb_traffic_analyzer_rename: RENAME: %s / %s\n",
+                smb_fname_src->base_name,
+                smb_fname_dst->base_name));
+        smb_traffic_analyzer_send_data(handle, &s_data, vfs_id_rename);
+        return s_data.result;
+}
+
+static int smb_traffic_analyzer_rmdir(vfs_handle_struct *handle, \
+                        const char *path)
+{
+        struct rmdir_data s_data;
+        s_data.result = SMB_VFS_NEXT_RMDIR(handle, path);
+        s_data.path = path;
+        DEBUG(10, ("smb_traffic_analyzer_rmdir: RMDIR: %s\n", path));
+        smb_traffic_analyzer_send_data(handle, &s_data, vfs_id_rmdir);
+        return s_data.result;
+}
+
+static int smb_traffic_analyzer_mkdir(vfs_handle_struct *handle, \
+                        const char *path, mode_t mode)
+{
+        struct mkdir_data s_data;
+        s_data.result = SMB_VFS_NEXT_MKDIR(handle, path, mode);
+        s_data.path = path;
+        s_data.mode = mode;
+        DEBUG(10, ("smb_traffic_analyzer_mkdir: MKDIR: %s\n", path));
+        smb_traffic_analyzer_send_data(handle,
+                        &s_data,
+                        vfs_id_mkdir);
+        return s_data.result;
+}
+
+static ssize_t smb_traffic_analyzer_sendfile(vfs_handle_struct *handle,
+                                int tofd,
+                                files_struct *fromfsp,
+                                const DATA_BLOB *hdr,
+                                SMB_OFF_T offset,
+                                size_t n)
+{
+        struct rw_data s_data;
+        s_data.len = SMB_VFS_NEXT_SENDFILE(handle,
+                        tofd, fromfsp, hdr, offset, n);
+        s_data.filename = fromfsp->fsp_name->base_name;
+        DEBUG(10, ("smb_traffic_analyzer_sendfile: sendfile(r): %s\n",
+                fsp_str_dbg(fromfsp)));
+        smb_traffic_analyzer_send_data(handle,
+                &s_data,
+                vfs_id_read);
+        return s_data.len;
+}
+
+static ssize_t smb_traffic_analyzer_recvfile(vfs_handle_struct *handle,
+                                int fromfd,
+                                files_struct *tofsp,
+                                SMB_OFF_T offset,
+                                size_t n)
+{
+        struct rw_data s_data;
+        s_data.len = SMB_VFS_NEXT_RECVFILE(handle,
+                        fromfd, tofsp, offset, n);
+        s_data.filename = tofsp->fsp_name->base_name;
+        DEBUG(10, ("smb_traffic_analyzer_recvfile: recvfile(w): %s\n",
+                fsp_str_dbg(tofsp)));
+        smb_traffic_analyzer_send_data(handle,
+                &s_data,
+                vfs_id_write);
+        return s_data.len;
+}
+
 
 static ssize_t smb_traffic_analyzer_read(vfs_handle_struct *handle, \
                                 files_struct *fsp, void *data, size_t n)
 {
-        ssize_t result;
-
-        result = SMB_VFS_NEXT_READ(handle, fsp, data, n);
+        struct rw_data s_data;
+
+        s_data.len = SMB_VFS_NEXT_READ(handle, fsp, data, n);
+        s_data.filename = fsp->fsp_name->base_name;
         DEBUG(10, ("smb_traffic_analyzer_read: READ: %s\n", fsp_str_dbg(fsp)));
 
         smb_traffic_analyzer_send_data(handle,
-                        result,
-                        fsp->fsp_name->base_name,
-                        false);
-        return result;
+                        &s_data,
+                        vfs_id_read);
+        return s_data.len;
 }
 
@@ -358 +816 @@
                 files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
 {
-        ssize_t result;
-
-        result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
-
+        struct rw_data s_data;
+
+        s_data.len = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
+        s_data.filename = fsp->fsp_name->base_name;
         DEBUG(10, ("smb_traffic_analyzer_pread: PREAD: %s\n",
                    fsp_str_dbg(fsp)));
 
         smb_traffic_analyzer_send_data(handle,
-                        result,
-                        fsp->fsp_name->base_name,
-                        false);
-
-        return result;
+                        &s_data,
+                        vfs_id_pread);
+
+        return s_data.len;
 }
 
@@ -376 +833 @@
                         files_struct *fsp, const void *data, size_t n)
 {
-        ssize_t result;
-
-        result = SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
-
+        struct rw_data s_data;
+
+        s_data.len = SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
+        s_data.filename = fsp->fsp_name->base_name;
         DEBUG(10, ("smb_traffic_analyzer_write: WRITE: %s\n",
                    fsp_str_dbg(fsp)));
 
         smb_traffic_analyzer_send_data(handle,
-                        result,
-                        fsp->fsp_name->base_name,
-                        true);
-        return result;
+                        &s_data,
+                        vfs_id_write);
+        return s_data.len;
 }
 
@@ -393 +849 @@
              files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
 {
-        ssize_t result;
-
-        result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
-
-        DEBUG(10, ("smb_traffic_analyzer_pwrite: PWRITE: %s\n", fsp_str_dbg(fsp)));
+        struct rw_data s_data;
+
+        s_data.len = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
+        s_data.filename = fsp->fsp_name->base_name;
+        DEBUG(10, ("smb_traffic_analyzer_pwrite: PWRITE: %s\n", \
+                fsp_str_dbg(fsp)));
 
         smb_traffic_analyzer_send_data(handle,
-                        result,
-                        fsp->fsp_name->base_name,
-                        true);
-        return result;
-}
-
+                        &s_data,
+                        vfs_id_pwrite);
+        return s_data.len;
+}
+
+static int smb_traffic_analyzer_open(vfs_handle_struct *handle, \
+        struct smb_filename *smb_fname, files_struct *fsp,\
+        int flags, mode_t mode)
+{
+        struct open_data s_data;
+
+        s_data.result = SMB_VFS_NEXT_OPEN( handle, smb_fname, fsp,
+                        flags, mode);
+        DEBUG(10,("smb_traffic_analyzer_open: OPEN: %s\n",
+                fsp_str_dbg(fsp)));
+        s_data.filename = fsp->fsp_name->base_name;
+        s_data.mode = mode;
+        smb_traffic_analyzer_send_data(handle,
+                        &s_data,
+                        vfs_id_open);
+        return s_data.result;
+}
+
+static int smb_traffic_analyzer_close(vfs_handle_struct *handle, \
+        files_struct *fsp)
+{
+        struct close_data s_data;
+        s_data.result = SMB_VFS_NEXT_CLOSE(handle, fsp);
+        DEBUG(10,("smb_traffic_analyzer_close: CLOSE: %s\n",
+                fsp_str_dbg(fsp)));
+        s_data.filename = fsp->fsp_name->base_name;
+        smb_traffic_analyzer_send_data(handle,
+                        &s_data,
+                        vfs_id_close);
+        return s_data.result;
+}
+
+        
 static struct vfs_fn_pointers vfs_smb_traffic_analyzer_fns = {
         .connect_fn = smb_traffic_analyzer_connect,
@@ -412 +901 @@
         .write = smb_traffic_analyzer_write,
         .pwrite = smb_traffic_analyzer_pwrite,
+        .mkdir = smb_traffic_analyzer_mkdir,
+        .rename = smb_traffic_analyzer_rename,
+        .chdir = smb_traffic_analyzer_chdir,
+        .open_fn = smb_traffic_analyzer_open,
+        .rmdir = smb_traffic_analyzer_rmdir,
+        .close_fn = smb_traffic_analyzer_close,
+        .sendfile = smb_traffic_analyzer_sendfile,
+        .recvfile = smb_traffic_analyzer_recvfile
 };
 
 /* Module initialization */
-
 NTSTATUS vfs_smb_traffic_analyzer_init(void)
 {

trunk/server/source3/modules/vfs_solarisacl.c

@@ -20 +20 @@
 
 #include "includes.h"
-
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "modules/vfs_solarisacl.h"
 
 /* typedef struct acl SOLARIS_ACE_T; */

trunk/server/source3/modules/vfs_streams_depot.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
 
 #undef DBGC_CLASS
@@ -662 +664 @@
         struct smb_filename *smb_fname_src_stream = NULL;
         struct smb_filename *smb_fname_dst_stream = NULL;
-        struct smb_filename *smb_fname_dst_mod = NULL;
         bool src_is_stream, dst_is_stream;
         NTSTATUS status;
@@ -693 +694 @@
         }
 
-        /*
-         * Handle passing in a stream name without the base file.  This is
-         * exercised by the NTRENAME streams rename path.
-         */
-        if (StrCaseCmp(smb_fname_dst->base_name, "./") == 0) {
-                status = create_synthetic_smb_fname(talloc_tos(),
-                                                    smb_fname_src->base_name,
-                                                    smb_fname_dst->stream_name,
-                                                    NULL, &smb_fname_dst_mod);
-                if (!NT_STATUS_IS_OK(status)) {
-                        errno = map_errno_from_nt_status(status);
-                        goto done;
-                }
-        }
-
-        status = stream_smb_fname(handle, (smb_fname_dst_mod ?
-                                           smb_fname_dst_mod : smb_fname_dst),
+        status = stream_smb_fname(handle, smb_fname_dst,
                                   &smb_fname_dst_stream, false);
         if (!NT_STATUS_IS_OK(status)) {
@@ -722 +707 @@
         TALLOC_FREE(smb_fname_src_stream);
         TALLOC_FREE(smb_fname_dst_stream);
-        TALLOC_FREE(smb_fname_dst_mod);
         return ret;
 }
@@ -893 +877 @@
 static struct vfs_fn_pointers vfs_streams_depot_fns = {
         .fs_capabilities = streams_depot_fs_capabilities,
-        .open = streams_depot_open,
+        .open_fn = streams_depot_open,
         .stat = streams_depot_stat,
         .lstat = streams_depot_lstat,

trunk/server/source3/modules/vfs_streams_xattr.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "../lib/crypto/md5.h"
 
 #undef DBGC_CLASS
@@ -1023 +1026 @@
 }
 
+static int streams_xattr_fallocate(struct vfs_handle_struct *handle,
+                                        struct files_struct *fsp,
+                                        enum vfs_fallocate_mode mode,
+                                        SMB_OFF_T offset,
+                                        SMB_OFF_T len)
+{
+        struct stream_io *sio =
+                (struct stream_io *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
+
+        DEBUG(10, ("streams_xattr_fallocate called for file %s offset %.0f"
+                "len = %.0f\n",
+                fsp_str_dbg(fsp), (double)offset, (double)len));
+
+        if (sio == NULL) {
+                return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
+        }
+
+        if (!streams_xattr_recheck(sio)) {
+                return errno;
+        }
+
+        /* Let the pwrite code path handle it. */
+        return ENOSYS;
+}
+
+
 static struct vfs_fn_pointers vfs_streams_xattr_fns = {
         .fs_capabilities = streams_xattr_fs_capabilities,
-        .open = streams_xattr_open,
+        .open_fn = streams_xattr_open,
         .stat = streams_xattr_stat,
         .fstat = streams_xattr_fstat,
@@ -1034 +1063 @@
         .rename = streams_xattr_rename,
         .ftruncate = streams_xattr_ftruncate,
+        .fallocate = streams_xattr_fallocate,
         .streaminfo = streams_xattr_streaminfo,
 };

trunk/server/source3/modules/vfs_syncops.c

@@ -3 +3 @@
  *
  * Copyright (C) Andrew Tridgell     2007
+ * Copyright (C) Christian Ambach, 2010-2011
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20 +21 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 
 /*
@@ -32 +35 @@
   On those filesystems this module provides a way to perform those
   operations safely.  
- */
-
-/*
+
   most of the performance loss with this module is in fsync on close(). 
-  You can disable that with syncops:onclose = no
- */
-static bool sync_onclose;
+  You can disable that with
+     syncops:onclose = no
+  that can be set either globally or per share.
+
+  On certain filesystems that only require the last data written to be
+  fsync()'ed, you can disable the metadata synchronization of this module with
+     syncops:onmeta = no
+  This option can be set either globally or per share.
+
+  you can also disable the module completely for a share with
+     syncops:disable = true
+
+ */
+
+struct syncops_config_data {
+        bool onclose;
+        bool onmeta;
+        bool disable;
+};
 
 /*
@@ -126 +143 @@
                           const struct smb_filename *smb_fname_dst)
 {
-        int ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
-        if (ret == 0) {
+
+        int ret;
+        struct syncops_config_data *config;
+
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct syncops_config_data,
+                                return -1);
+
+        ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
+        if (ret == 0 && config->onmeta && !config->disable) {
                 syncops_two_names(smb_fname_src->base_name,
                                   smb_fname_dst->base_name);
@@ -136 +161 @@
 /* handle the rest with a macro */
 #define SYNCOPS_NEXT(op, fname, args) do {   \
-        int ret = SMB_VFS_NEXT_ ## op args; \
-        if (ret == 0 && fname) syncops_name(fname); \
+        int ret; \
+        struct syncops_config_data *config; \
+        SMB_VFS_HANDLE_GET_DATA(handle, config, \
+                                struct syncops_config_data, \
+                                return -1); \
+        ret = SMB_VFS_NEXT_ ## op args; \
+        if (ret == 0 \
+                && config->onmeta && !config->disable  \
+                && fname) syncops_name(fname); \
         return ret; \
 } while (0)
 
 #define SYNCOPS_NEXT_SMB_FNAME(op, fname, args) do {   \
-        int ret = SMB_VFS_NEXT_ ## op args; \
-        if (ret == 0 && fname) syncops_smb_fname(fname); \
+        int ret; \
+        struct syncops_config_data *config; \
+        SMB_VFS_HANDLE_GET_DATA(handle, config, \
+                                struct syncops_config_data, \
+                                return -1); \
+        ret = SMB_VFS_NEXT_ ## op args; \
+        if (ret == 0 \
+        && config->onmeta && !config->disable \
+        && fname) syncops_smb_fname(fname); \
         return ret; \
 } while (0)
@@ -192 +231 @@
 static int syncops_close(vfs_handle_struct *handle, files_struct *fsp)
 {
-        if (fsp->can_write && sync_onclose) {
+        struct syncops_config_data *config;
+
+        SMB_VFS_HANDLE_GET_DATA(handle, config,
+                                struct syncops_config_data,
+                                return -1);
+
+        if (fsp->can_write && config->onclose) {
                 /* ideally we'd only do this if we have written some
                  data, but there is no flag for that in fsp yet. */
@@ -200 +245 @@
 }
 
+static int syncops_connect(struct vfs_handle_struct *handle, const char *service,
+                           const char *user)
+{
+
+        struct syncops_config_data *config;
+        int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
+        if (ret < 0) {
+                return ret;
+        }
+
+        config = talloc_zero(handle->conn, struct syncops_config_data);
+        if (!config) {
+                SMB_VFS_NEXT_DISCONNECT(handle);
+                DEBUG(0, ("talloc_zero() failed\n"));
+                return -1;
+        }
+
+        config->onclose = lp_parm_bool(SNUM(handle->conn), "syncops",
+                                        "onclose", true);
+
+        config->onmeta = lp_parm_bool(SNUM(handle->conn), "syncops",
+                                        "onmeta", true);
+
+        config->disable = lp_parm_bool(SNUM(handle->conn), "syncops",
+                                        "disable", false);
+
+        SMB_VFS_HANDLE_SET_DATA(handle, config,
+                                NULL, struct syncops_config_data,
+                                return -1);
+
+        return 0;
+
+}
 
 static struct vfs_fn_pointers vfs_syncops_fns = {
+        .connect_fn = syncops_connect,
         .mkdir = syncops_mkdir,
         .rmdir = syncops_rmdir,
-        .open = syncops_open,
+        .open_fn = syncops_open,
         .rename = syncops_rename,
         .unlink = syncops_unlink,
@@ -223 +302 @@
                 return ret;
 
-        sync_onclose = lp_parm_bool(-1, "syncops", "onclose", true);
-        
         return ret;
 }

trunk/server/source3/modules/vfs_tru64acl.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
+#include "modules/vfs_tru64acl.h"
 
 /* prototypes for private functions first - for clarity */

trunk/server/source3/modules/vfs_tsmsm.c

@@ -40 +40 @@
 
 #include "includes.h"
+#include "smbd/smbd.h"
 
 #ifndef USE_DMAPI
@@ -147 +148 @@
 
 static bool tsmsm_is_offline(struct vfs_handle_struct *handle, 
-                            const char *path,
-                            SMB_STRUCT_STAT *stbuf) {
+                             const struct smb_filename *fname,
+                             SMB_STRUCT_STAT *stbuf)
+{
         struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
         const dm_sessid_t *dmsession_id;
@@ -159 +161 @@
         char *buf = NULL;
         size_t buflen;
+        NTSTATUS status;
+        char *path;
+
+        status = get_full_smb_filename(talloc_tos(), fname, &path);
+        if (!NT_STATUS_IS_OK(status)) {
+                errno = map_errno_from_nt_status(status);
+                return false;
+        }
 
         /* if the file has more than FILE_IS_ONLINE_RATIO of blocks available,
            then assume it is not offline (it may not be 100%, as it could be sparse) */
-        if (512 * (off_t)stbuf->st_ex_blocks >=
+        if (512 * stbuf->st_ex_blocks >=
             stbuf->st_ex_size * tsmd->online_ratio) {
-                DEBUG(10,("%s not offline: st_blocks=%ld st_size=%ld "
+                DEBUG(10,("%s not offline: st_blocks=%llu st_size=%llu "
                           "online_ratio=%.2f\n", path,
-                          (long)stbuf->st_ex_blocks,
-                          (long)stbuf->st_ex_size, tsmd->online_ratio));
+                          (unsigned long long)stbuf->st_ex_blocks,
+                          (unsigned long long)stbuf->st_ex_size, tsmd->online_ratio));
                 return false;
         }
@@ -264 +274 @@
         */
         if(SMB_VFS_FSTAT(fsp, &sbuf) == 0) {
-                DEBUG(10,("tsmsm_aio_force st_blocks=%ld st_size=%ld "
-                          "online_ratio=%.2f\n", (long)sbuf.st_ex_blocks,
-                          (long)sbuf.st_ex_size, tsmd->online_ratio));
-                return !(512 * (off_t)sbuf.st_ex_blocks >=
+                DEBUG(10,("tsmsm_aio_force st_blocks=%llu st_size=%llu "
+                          "online_ratio=%.2f\n", (unsigned long long)sbuf.st_ex_blocks,
+                          (unsigned long long)sbuf.st_ex_size, tsmd->online_ratio));
+                return !(512 * sbuf.st_ex_blocks >=
                          sbuf.st_ex_size * tsmd->online_ratio);
         }
@@ -341 +351 @@
 
 static int tsmsm_set_offline(struct vfs_handle_struct *handle, 
-                             const char *path) {
+                             const struct smb_filename *fname)
+{
         struct tsmsm_struct *tsmd = (struct tsmsm_struct *) handle->data;
         int result = 0;
         char *command;
+        NTSTATUS status;
+        char *path;
 
         if (tsmd->hsmscript == NULL) {
@@ -351 +364 @@
                 return 0;
         }
+
+        status = get_full_smb_filename(talloc_tos(), fname, &path);
+        if (!NT_STATUS_IS_OK(status)) {
+                errno = map_errno_from_nt_status(status);
+                return false;
+        }
 
         /* Now, call the script */

trunk/server/source3/modules/vfs_xattr_tdb.c

@@ -19 +19 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 #include "librpc/gen_ndr/xattr.h"
 #include "librpc/gen_ndr/ndr_xattr.h"
+#include "../librpc/gen_ndr/ndr_netlogon.h"
+#include "dbwrap.h"
+#include "util_tdb.h"
 
 #undef DBGC_CLASS
@@ -48 +53 @@
         blob = data_blob_const(data->dptr, data->dsize);
 
-        ndr_err = ndr_pull_struct_blob(
-                &blob, result, NULL, result,
+        ndr_err = ndr_pull_struct_blob(&blob, result, result,
                 (ndr_pull_flags_fn_t)ndr_pull_tdb_xattrs);
 
@@ -56 +60 @@
                           ndr_errstr(ndr_err)));
                 TALLOC_FREE(result);
-                return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
         }
 
@@ -74 +78 @@
         enum ndr_err_code ndr_err;
 
-        ndr_err = ndr_push_struct_blob(
-                &blob, mem_ctx, NULL, attribs,
+        ndr_err = ndr_push_struct_blob(&blob, mem_ctx, attribs,
                 (ndr_push_flags_fn_t)ndr_push_tdb_xattrs);
 
@@ -81 +84 @@
                 DEBUG(0, ("ndr_push_tdb_xattrs failed: %s\n",
                           ndr_errstr(ndr_err)));
-                return ndr_map_error2ntstatus(ndr_err);;
+                return ndr_map_error2ntstatus(ndr_err);
         }
 
@@ -725 +728 @@
                           const char *user)
 {
-        fstring sname;
+        char *sname = NULL;
         int res, snum;
         struct db_context *db;
@@ -734 +737 @@
         }
 
-        fstrcpy(sname, service);
-        snum = find_service(sname);
-        if (snum == -1) {
+        snum = find_service(talloc_tos(), service, &sname);
+        if (snum == -1 || sname == NULL) {
                 /*
                  * Should not happen, but we should not fail just *here*.

trunk/server/source3/modules/vfs_zfsacl.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 #include "nfs4_acls.h"
+
+#if HAVE_FREEBSD_SUNACL_H
+#include "sunacl.h"
+#endif
 
 #undef DBGC_CLASS
@@ -107 +113 @@
         SMB4ACE_T *smbace;
         TALLOC_CTX      *mem_ctx;
+        bool have_special_id = false;
 
         /* allocate the field of ZFS aces */
@@ -124 +131 @@
                 acebuf[i].a_flags       = aceprop->aceFlags;
                 acebuf[i].a_access_mask = aceprop->aceMask;
+                /* SYNC on acls is a no-op on ZFS.
+                   See bug #7909. */
+                acebuf[i].a_access_mask &= ~SMB_ACE4_SYNCHRONIZE;
                 acebuf[i].a_who         = aceprop->who.id;
                 if(aceprop->flags & SMB_ACE4_ID_SPECIAL) {
@@ -141 +151 @@
                                 continue; /* don't add it !!! */
                         }
+                        have_special_id = true;
                 }
         }
+
+        if (!have_special_id
+            && lp_parm_bool(fsp->conn->params->service, "zfsacl",
+                            "denymissingspecial", false)) {
+                errno = EACCES;
+                return false;
+        }
+
         SMB_ASSERT(i == naces);
 
@@ -209 +228 @@
                          files_struct *fsp,
                          uint32 security_info_sent,
-                         const SEC_DESC *psd)
+                         const struct security_descriptor *psd)
 {
         return zfs_set_nt_acl(handle, fsp, security_info_sent, psd);
@@ -245 +264 @@
 */
 
-SMB_ACL_T zfsacl_fail__sys_acl_get_file(vfs_handle_struct *handle,
-                                        const char *path_p,
-                                        SMB_ACL_TYPE_T type)
+static SMB_ACL_T zfsacl_fail__sys_acl_get_file(vfs_handle_struct *handle,
+                                               const char *path_p,
+                                               SMB_ACL_TYPE_T type)
 {
         return (SMB_ACL_T)NULL;
 }
-SMB_ACL_T zfsacl_fail__sys_acl_get_fd(vfs_handle_struct *handle,
-                                      files_struct *fsp,
-                                      int fd)
+
+static SMB_ACL_T zfsacl_fail__sys_acl_get_fd(vfs_handle_struct *handle,
+                                             files_struct *fsp)
 {
         return (SMB_ACL_T)NULL;
 }
 
-int zfsacl_fail__sys_acl_set_file(vfs_handle_struct *handle,
-                                  const char *name,
-                                  SMB_ACL_TYPE_T type,
-                                  SMB_ACL_T theacl)
+static int zfsacl_fail__sys_acl_set_file(vfs_handle_struct *handle,
+                                         const char *name,
+                                         SMB_ACL_TYPE_T type,
+                                         SMB_ACL_T theacl)
 {
         return -1;
 }
 
-int zfsacl_fail__sys_acl_set_fd(vfs_handle_struct *handle,
-                                files_struct *fsp,
-                                int fd, SMB_ACL_T theacl)
+static int zfsacl_fail__sys_acl_set_fd(vfs_handle_struct *handle,
+                                       files_struct *fsp,
+                                       SMB_ACL_T theacl)
 {
         return -1;
 }
 
-int zfsacl_fail__sys_acl_delete_def_file(vfs_handle_struct *handle,
-                                         const char *path)
+static int zfsacl_fail__sys_acl_delete_def_file(vfs_handle_struct *handle,
+                                                const char *path)
 {
         return -1;

trunk/server/source3/modules/weird.c

@@ -128 +128 @@
 NTSTATUS charset_weird_init(void)
 {
-        return smb_register_charset(&weird_functions);
+        if (!smb_register_charset(&weird_functions)) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        return NT_STATUS_OK;
 }