Changeset 988 for vendor/current/source4/ntvfs/posix

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source4/ntvfs/posix

Files:

• posix_eadb.c (added)
• posix_eadb.h (added)
• pvfs_acl.c (modified) (30 diffs)
• pvfs_acl_nfs4.c (modified) (5 diffs)
• pvfs_acl_xattr.c (modified) (1 diff)
• pvfs_dirlist.c (modified) (3 diffs)
• pvfs_fileinfo.c (modified) (1 diff)
• pvfs_fsinfo.c (modified) (1 diff)
• pvfs_ioctl.c (modified) (1 diff)
• pvfs_lock.c (modified) (11 diffs)
• pvfs_mkdir.c (modified) (6 diffs)
• pvfs_notify.c (modified) (2 diffs)
• pvfs_open.c (modified) (14 diffs)
• pvfs_oplock.c (modified) (5 diffs)
• pvfs_qfileinfo.c (modified) (5 diffs)
• pvfs_read.c (modified) (2 diffs)
• pvfs_rename.c (modified) (2 diffs)
• pvfs_resolve.c (modified) (8 diffs)
• pvfs_search.c (modified) (2 diffs)
• pvfs_setfileinfo.c (modified) (6 diffs)
• pvfs_sys.c (modified) (18 diffs)
• pvfs_unlink.c (modified) (1 diff)
• pvfs_util.c (modified) (7 diffs)
• pvfs_wait.c (modified) (6 diffs)
• pvfs_write.c (modified) (1 diff)
• pvfs_xattr.c (modified) (4 diffs)
• python/pyposix_eadb.c (added)
• python/pyxattr_native.c (modified) (6 diffs)
• python/pyxattr_tdb.c (modified) (8 diffs)
• vfs_posix.c (modified) (9 diffs)
• vfs_posix.h (modified) (3 diffs)
• wscript_build (modified) (3 diffs)
• xattr_system.c (modified) (4 diffs)
• xattr_tdb.c (deleted)

vendor/current/source4/ntvfs/posix/pvfs_acl.c

@@ -21 +21 @@
 
 #include "includes.h"
+#include "system/passwd.h"
 #include "auth/auth.h"
 #include "vfs_posix.h"
@@ -27 +28 @@
 #include "param/param.h"
 #include "../lib/util/unix_privs.h"
-
-#if defined(UID_WRAPPER)
-#if !defined(UID_WRAPPER_REPLACE) && !defined(UID_WRAPPER_NOT_REPLACE)
-#define UID_WRAPPER_REPLACE
-#include "../uid_wrapper/uid_wrapper.h"
-#endif
-#else
-#define uwrap_enabled() 0
-#endif
+#include "lib/util/samba_modules.h"
 
 /* the list of currently registered ACL backends */
@@ -90 +83 @@
 }
 
-NTSTATUS pvfs_acl_init(struct loadparm_context *lp_ctx)
+NTSTATUS pvfs_acl_init(void)
 {
         static bool initialized = false;
@@ -101 +94 @@
         initialized = true;
 
-        shared_init = load_samba_modules(NULL, lp_ctx, "pvfs_acl");
+        shared_init = load_samba_modules(NULL, "pvfs_acl");
 
         run_init_functions(static_init);
@@ -159 +152 @@
         mode_t mode;
         struct id_map *ids;
-        struct composite_context *ctx;
 
         *psd = security_descriptor_initialise(req);
@@ -178 +170 @@
         ids[1].sid = NULL;
 
-        ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
-        NT_STATUS_HAVE_NO_MEMORY(ctx);
-
-        status = wbc_xids_to_sids_recv(ctx, &ids);
+        status = wbc_xids_to_sids(pvfs->ntvfs->ctx->event_ctx, ids, 2);
         NT_STATUS_NOT_OK_RETURN(status);
 
@@ -276 +265 @@
                 sd->sacl = NULL;
         }
+}
+
+static bool pvfs_privileged_access(uid_t uid)
+{
+        uid_t euid;
+
+        if (uid_wrapper_enabled()) {
+                setenv("UID_WRAPPER_MYUID", "1", 1);
+        }
+
+        euid = geteuid();
+
+        if (uid_wrapper_enabled()) {
+                unsetenv("UID_WRAPPER_MYUID");
+        }
+
+        return (uid == euid);
 }
 
@@ -295 +301 @@
         gid_t new_gid = -1;
         struct id_map *ids;
-        struct composite_context *ctx;
 
         if (pvfs->acl_ops != NULL) {
@@ -326 +331 @@
                 if (!dom_sid_equal(sd->owner_sid, new_sd->owner_sid)) {
                         ids->sid = new_sd->owner_sid;
-                        ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
-                        NT_STATUS_HAVE_NO_MEMORY(ctx);
-                        status = wbc_sids_to_xids_recv(ctx, &ids);
+                        status = wbc_sids_to_xids(pvfs->ntvfs->ctx->event_ctx,
+                                                  ids, 1);
                         NT_STATUS_NOT_OK_RETURN(status);
 
@@ -338 +342 @@
                 sd->owner_sid = new_sd->owner_sid;
         }
+
         if (secinfo_flags & SECINFO_GROUP) {
                 if (!(access_mask & SEC_STD_WRITE_OWNER)) {
@@ -344 +349 @@
                 if (!dom_sid_equal(sd->group_sid, new_sd->group_sid)) {
                         ids->sid = new_sd->group_sid;
-                        ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx, ids, 1, ids);
-                        NT_STATUS_HAVE_NO_MEMORY(ctx);
-                        status = wbc_sids_to_xids_recv(ctx, &ids);
+                        status = wbc_sids_to_xids(pvfs->ntvfs->ctx->event_ctx,
+                                                  ids, 1);
                         NT_STATUS_NOT_OK_RETURN(status);
 
@@ -357 +361 @@
                 sd->group_sid = new_sd->group_sid;
         }
+
         if (secinfo_flags & SECINFO_DACL) {
                 if (!(access_mask & SEC_STD_WRITE_DAC)) {
@@ -363 +368 @@
                 sd->dacl = new_sd->dacl;
                 pvfs_translate_generic_bits(sd->dacl);
-        }
+                sd->type |= SEC_DESC_DACL_PRESENT;
+        }
+
         if (secinfo_flags & SECINFO_SACL) {
                 if (!(access_mask & SEC_FLAG_SYSTEM_SECURITY)) {
@@ -370 +377 @@
                 sd->sacl = new_sd->sacl;
                 pvfs_translate_generic_bits(sd->sacl);
+                sd->type |= SEC_DESC_SACL_PRESENT;
+        }
+
+        if (secinfo_flags & SECINFO_PROTECTED_DACL) {
+                if (new_sd->type & SEC_DESC_DACL_PROTECTED) {
+                        sd->type |= SEC_DESC_DACL_PROTECTED;
+                } else {
+                        sd->type &= ~SEC_DESC_DACL_PROTECTED;
+                }
+        }
+
+        if (secinfo_flags & SECINFO_PROTECTED_SACL) {
+                if (new_sd->type & SEC_DESC_SACL_PROTECTED) {
+                        sd->type |= SEC_DESC_SACL_PROTECTED;
+                } else {
+                        sd->type &= ~SEC_DESC_SACL_PROTECTED;
+                }
         }
 
@@ -389 +413 @@
                 }
                 if (errno == EPERM) {
-                        if (uwrap_enabled()) {
+                        if (pvfs_privileged_access(name->st.st_uid)) {
                                 ret = 0;
                         } else {
@@ -484 +508 @@
         }
         ngroups = getgroups(0, NULL);
-        if (ngroups == 0) {
+        if (ngroups <= 0) {
                 return false;
         }
@@ -515 +539 @@
                                        uint32_t *access_mask)
 {
-        uid_t uid = geteuid();
-        uint32_t max_bits = SEC_RIGHTS_FILE_READ | SEC_FILE_ALL;
+        uint32_t max_bits = 0;
         struct security_token *token = req->session_info->security_token;
 
@@ -523 +546 @@
         }
 
-        if (name == NULL || uid == name->st.st_uid) {
-                max_bits |= SEC_STD_ALL;
-        } else if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
-                max_bits |= SEC_STD_DELETE;
-        }
-
-        if (name == NULL ||
-            (name->st.st_mode & S_IWOTH) ||
-            ((name->st.st_mode & S_IWGRP) && 
-             pvfs_group_member(pvfs, name->st.st_gid))) {
-                max_bits |= SEC_STD_ALL;
-        }
-
-        if (uwrap_enabled()) {
-                /* when running with the uid wrapper, files will be created
-                   owned by the ruid, but we may have a different simulated 
-                   euid. We need to force the permission bits as though the 
-                   files owner matches the euid */
-                max_bits |= SEC_STD_ALL;
+        if (name == NULL) {
+                max_bits |= SEC_RIGHTS_FILE_ALL | SEC_STD_ALL;
+        } else if (pvfs_privileged_access(name->st.st_uid)) {
+                /* use the IxUSR bits */
+                if ((name->st.st_mode & S_IWUSR)) {
+                        max_bits |= SEC_RIGHTS_FILE_ALL | SEC_STD_ALL;
+                } else if ((name->st.st_mode & (S_IRUSR | S_IXUSR))) {
+                        max_bits |= SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_EXECUTE | SEC_STD_ALL;
+                }
+        } else if (pvfs_group_member(pvfs, name->st.st_gid)) {
+                /* use the IxGRP bits */
+                if ((name->st.st_mode & S_IWGRP)) {
+                        max_bits |= SEC_RIGHTS_FILE_ALL | SEC_STD_ALL;
+                } else if ((name->st.st_mode & (S_IRGRP | S_IXGRP))) {
+                        max_bits |= SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_EXECUTE | SEC_STD_ALL;
+                }
+        } else {
+                /* use the IxOTH bits */
+                if ((name->st.st_mode & S_IWOTH)) {
+                        max_bits |= SEC_RIGHTS_FILE_ALL | SEC_STD_ALL;
+                } else if ((name->st.st_mode & (S_IROTH | S_IXOTH))) {
+                        max_bits |= SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_EXECUTE | SEC_STD_ALL;
+                }
         }
 
@@ -564 +591 @@
 
         if (*access_mask & ~max_bits) {
-                DEBUG(0,(__location__ " denied access to '%s' - wanted 0x%08x but got 0x%08x (missing 0x%08x)\n",
+                DEBUG(5,(__location__ " denied access to '%s' - wanted 0x%08x but got 0x%08x (missing 0x%08x)\n",
                          name?name->full_name:"(new file)", *access_mask, max_bits, *access_mask & ~max_bits));
                 return NT_STATUS_ACCESS_DENIED;
         }
 
-        if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
+        if (pvfs->ntvfs->ctx->protocol < PROTOCOL_SMB2_02) {
                 /* on SMB, this bit is always granted, even if not
                    asked for */
@@ -596 +623 @@
 
         /* on SMB2 a blank access mask is always denied */
-        if (pvfs->ntvfs->ctx->protocol == PROTOCOL_SMB2 &&
+        if (pvfs->ntvfs->ctx->protocol >= PROTOCOL_SMB2_02 &&
             *access_mask == 0) {
                 return NT_STATUS_ACCESS_DENIED;
@@ -622 +649 @@
         /* expand the generic access bits to file specific bits */
         *access_mask = pvfs_translate_mask(*access_mask);
-        if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
+        if (pvfs->ntvfs->ctx->protocol < PROTOCOL_SMB2_02) {
                 *access_mask &= ~SEC_FILE_READ_ATTRIBUTE;
         }
@@ -647 +674 @@
         status = se_access_check(sd, token, *access_mask, access_mask);
         talloc_free(acl);
+
+        /* if we used a NT acl, then allow access override if the
+           share allows for posix permission override
+        */
+        if (NT_STATUS_IS_OK(status)) {
+                name->allow_override = (pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) != 0;
+        }
+
 done:
-        if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
+        if (pvfs->ntvfs->ctx->protocol < PROTOCOL_SMB2_02) {
                 /* on SMB, this bit is always granted, even if not
                    asked for */
@@ -746 +781 @@
         }
 
-        if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
+        if (pvfs->ntvfs->ctx->protocol < PROTOCOL_SMB2_02) {
                 /* on SMB, this bit is always granted, even if not
                    asked for */
@@ -775 +810 @@
         }
 
-        return pvfs_access_check_simple(pvfs, req, parent, access_mask);
+        status = pvfs_access_check_simple(pvfs, req, parent, access_mask);
+        if (NT_STATUS_IS_OK(status) && parent->allow_override) {
+                name->allow_override = true;
+        }
+        return status;
 }
 
@@ -899 +938 @@
         struct security_descriptor *parent_sd, *sd;
         struct id_map *ids;
-        struct composite_context *ctx;
         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 
@@ -905 +943 @@
 
         acl = talloc(req, struct xattr_NTACL);
-        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(acl, tmp_ctx);
+        if (acl == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
 
         status = pvfs_acl_load(pvfs, parent, -1, acl);
@@ -912 +953 @@
                 return NT_STATUS_OK;
         }
-        NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(tmp_ctx);
+                return status;
+        }
 
         switch (acl->version) {
@@ -933 +977 @@
         /* create the new sd */
         sd = security_descriptor_initialise(req);
-        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sd, tmp_ctx);
+        if (sd == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
 
         ids = talloc_array(sd, struct id_map, 2);
-        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ids, tmp_ctx);
+        if (ids == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
 
         ids[0].xid.id = geteuid();
@@ -948 +998 @@
         ids[1].status = ID_UNKNOWN;
 
-        ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, ids, 2, ids);
-        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(ctx, tmp_ctx);
-
-        status = wbc_xids_to_sids_recv(ctx, &ids);
-        NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
+        status = wbc_xids_to_sids(pvfs->ntvfs->ctx->event_ctx, ids, 2);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(tmp_ctx);
+                return status;
+        }
 
         sd->owner_sid = talloc_steal(sd, ids[0].sid);
@@ -961 +1011 @@
         /* fill in the aces from the parent */
         status = pvfs_acl_inherit_aces(pvfs, parent_sd, sd, container);
-        NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(tmp_ctx);
+                return status;
+        }
 
         /* if there is nothing to inherit then we fallback to the

vendor/current/source4/ntvfs/posix/pvfs_acl_nfs4.c

@@ -27 +27 @@
 #include "libcli/security/security.h"
 
+NTSTATUS pvfs_acl_nfs4_init(void);
+
 #define ACE4_IDENTIFIER_GROUP 0x40
 
@@ -41 +43 @@
         int i, num_ids;
         struct id_map *ids;
-        struct composite_context *ctx;
 
         acl = talloc_zero(mem_ctx, struct nfs4acl);
@@ -90 +91 @@
         /* Allocate memory for the sids from the security descriptor to be on
          * the safe side. */
-        ctx = wbc_xids_to_sids_send(pvfs->wbc_ctx, sd, num_ids, ids);
-        NT_STATUS_HAVE_NO_MEMORY(ctx);
-        status = wbc_xids_to_sids_recv(ctx, &ids);
+        status = wbc_xids_to_sids(pvfs->ntvfs->ctx->event_ctx, ids, num_ids);
         NT_STATUS_NOT_OK_RETURN(status);
 
@@ -123 +122 @@
         TALLOC_CTX *tmp_ctx;
         struct id_map *ids;
-        struct composite_context *ctx;
 
         tmp_ctx = talloc_new(pvfs);
@@ -158 +156 @@
         }
 
-        ctx = wbc_sids_to_xids_send(pvfs->wbc_ctx,ids, acl.a_count, ids);
-        if (ctx == NULL) {
-                talloc_free(tmp_ctx);
-                return NT_STATUS_NO_MEMORY;
-        }
-        status = wbc_sids_to_xids_recv(ctx, &ids);
+        status = wbc_sids_to_xids(pvfs->ntvfs->ctx->event_ctx, ids,
+                                  acl.a_count);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(tmp_ctx);

vendor/current/source4/ntvfs/posix/pvfs_acl_xattr.c

@@ -24 +24 @@
 #include "../lib/util/unix_privs.h"
 #include "librpc/gen_ndr/ndr_xattr.h"
+
+NTSTATUS pvfs_acl_xattr_init(void);
 
 /*

vendor/current/source4/ntvfs/posix/pvfs_dirlist.c

@@ -200 +200 @@
                 (*ofs) = DIR_OFFSET_DOTDOT;
                 dir->offset = *ofs;
-                if (ms_fnmatch(dir->pattern, ".", protocol) == 0) {
+                if (ms_fnmatch_protocol(dir->pattern, ".", protocol) == 0) {
                         dcache_add(dir, ".");
                         return ".";
@@ -209 +209 @@
                 (*ofs) = DIR_OFFSET_BASE;
                 dir->offset = *ofs;
-                if (ms_fnmatch(dir->pattern, "..", protocol) == 0) {
+                if (ms_fnmatch_protocol(dir->pattern, "..", protocol) == 0) {
                         dcache_add(dir, "..");
                         return "..";
@@ -229 +229 @@
                 }
 
-                if (ms_fnmatch(dir->pattern, dname, protocol) != 0) {
+                if (ms_fnmatch_protocol(dir->pattern, dname, protocol) != 0) {
                         char *short_name = pvfs_short_name_component(dir->pvfs, dname);
                         if (short_name == NULL ||
-                            ms_fnmatch(dir->pattern, short_name, protocol) != 0) {
+                            ms_fnmatch_protocol(dir->pattern, short_name, protocol) != 0) {
                                 talloc_free(short_name);
                                 continue;

vendor/current/source4/ntvfs/posix/pvfs_fileinfo.c

@@ -82 +82 @@
         name->dos.alloc_size = pvfs_round_alloc_size(pvfs, name->st.st_size);
         name->dos.nlink = name->st.st_nlink;
-        name->dos.ea_size = 4;
-        if (pvfs->ntvfs->ctx->protocol == PROTOCOL_SMB2) {
+        name->dos.ea_size = 4;  /* TODO: Fill this in without hitting the stream bad in pvfs_doseas_load() */
+        if (pvfs->ntvfs->ctx->protocol >= PROTOCOL_SMB2_02) {
                 /* SMB2 represents a null EA with zero bytes */
                 name->dos.ea_size = 0;

vendor/current/source4/ntvfs/posix/pvfs_fsinfo.c

@@ -202 +202 @@
                 return NT_STATUS_OK;
 
+        case RAW_QFS_SECTOR_SIZE_INFORMATION:
+                fs->sector_size_info.out.logical_bytes_per_sector = block_size;
+                fs->sector_size_info.out.phys_bytes_per_sector_atomic
+                                                                = block_size;
+                fs->sector_size_info.out.phys_bytes_per_sector_perf
+                                                                = block_size;
+                fs->sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic
+                                                                = block_size;
+                fs->sector_size_info.out.flags
+                                        = QFS_SSINFO_FLAGS_ALIGNED_DEVICE
+                                | QFS_SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE;
+                fs->sector_size_info.out.byte_off_sector_align = 0;
+                fs->sector_size_info.out.byte_off_partition_align = 0;
+                return NT_STATUS_OK;
+
         default:
                 break;

vendor/current/source4/ntvfs/posix/pvfs_ioctl.c

@@ -22 +22 @@
 #include "includes.h"
 #include "vfs_posix.h"
-#include "libcli/raw/ioctl.h"
+#include "../libcli/smb/smb_constants.h"
 
 /*

vendor/current/source4/ntvfs/posix/pvfs_lock.c

@@ -40 +40 @@
         }
 
-        return brl_locktest(pvfs->brl_context,
+        return brlock_locktest(pvfs->brl_context,
                             f->brl_handle,
                             smbpid,
@@ -71 +71 @@
         /* undo the locks we just did */
         for (i--;i>=0;i--) {
-                brl_unlock(pvfs->brl_context,
+                brlock_unlock(pvfs->brl_context,
                            f->brl_handle,
                            locks[i].pid,
@@ -117 +117 @@
         /* we don't retry on a cancel */
         if (reason == PVFS_WAIT_CANCEL) {
-                if (pvfs->ntvfs->ctx->protocol != PROTOCOL_SMB2) {
+                if (pvfs->ntvfs->ctx->protocol < PROTOCOL_SMB2_02) {
                         status = NT_STATUS_FILE_LOCK_CONFLICT;
                 } else {
@@ -128 +128 @@
                  * FILE_LOCK_CONFLICT in the error case
                  */
-                status = brl_lock(pvfs->brl_context,
+                status = brlock_lock(pvfs->brl_context,
                                   f->brl_handle,
                                   locks[pending->pending_lock].pid,
@@ -144 +144 @@
         if (NT_STATUS_IS_OK(status) || timed_out) {
                 NTSTATUS status2;
-                status2 = brl_remove_pending(pvfs->brl_context, 
+                status2 = brlock_remove_pending(pvfs->brl_context, 
                                              f->brl_handle, pending);
                 if (!NT_STATUS_IS_OK(status2)) {
@@ -178 +178 @@
                 }
 
-                status = brl_lock(pvfs->brl_context,
+                status = brlock_lock(pvfs->brl_context,
                                   f->brl_handle,
                                   locks[i].pid,
@@ -226 +226 @@
                 DEBUG(5,("pvfs_lock: removing %.0f locks on close\n", 
                          (double)f->lock_count));
-                brl_close(f->pvfs->brl_context, f->brl_handle);
+                brlock_close(f->pvfs->brl_context, f->brl_handle);
                 f->lock_count = 0;
         }
@@ -325 +325 @@
 
                 pending->end_time = 
-                        timeval_current_ofs(lck->lockx.in.timeout/1000,
-                                            1000*(lck->lockx.in.timeout%1000));
+                        timeval_current_ofs_msec(lck->lockx.in.timeout);
         }
 
@@ -351 +350 @@
 
         for (i=0;i<lck->lockx.in.ulock_cnt;i++) {
-                status = brl_unlock(pvfs->brl_context,
+                status = brlock_unlock(pvfs->brl_context,
                                     f->brl_handle,
                                     locks[i].pid,
@@ -370 +369 @@
                 }
 
-                status = brl_lock(pvfs->brl_context,
+                status = brlock_lock(pvfs->brl_context,
                                   f->brl_handle,
                                   locks[i].pid,
@@ -395 +394 @@
                         /* undo the locks we just did */
                         for (i--;i>=0;i--) {
-                                brl_unlock(pvfs->brl_context,
+                                brlock_unlock(pvfs->brl_context,
                                            f->brl_handle,
                                            locks[i].pid,

vendor/current/source4/ntvfs/posix/pvfs_mkdir.c

@@ -52 +52 @@
         mode = pvfs_fileperms(pvfs, FILE_ATTRIBUTE_DIRECTORY);
 
-        if (pvfs_sys_mkdir(pvfs, name->full_name, mode) == -1) {
+        if (pvfs_sys_mkdir(pvfs, name->full_name, mode, name->allow_override) == -1) {
                 return pvfs_map_errno(pvfs, errno);
         }
@@ -70 +70 @@
         status = pvfs_acl_inherit(pvfs, req, name, -1);
         if (!NT_STATUS_IS_OK(status)) {
-                pvfs_sys_rmdir(pvfs, name->full_name);
+                pvfs_sys_rmdir(pvfs, name->full_name, name->allow_override);
                 return status;
         }
@@ -79 +79 @@
                                          md->t2mkdir.in.eas);
         if (!NT_STATUS_IS_OK(status)) {
-                pvfs_sys_rmdir(pvfs, name->full_name);
+                pvfs_sys_rmdir(pvfs, name->full_name, name->allow_override);
                 return status;
         }
@@ -128 +128 @@
         mode = pvfs_fileperms(pvfs, FILE_ATTRIBUTE_DIRECTORY);
 
-        if (pvfs_sys_mkdir(pvfs, name->full_name, mode) == -1) {
+        if (pvfs_sys_mkdir(pvfs, name->full_name, mode, name->allow_override) == -1) {
                 return pvfs_map_errno(pvfs, errno);
         }
@@ -137 +137 @@
         status = pvfs_acl_inherit(pvfs, req, name, -1);
         if (!NT_STATUS_IS_OK(status)) {
-                pvfs_sys_rmdir(pvfs, name->full_name);
+                pvfs_sys_rmdir(pvfs, name->full_name, name->allow_override);
                 return status;
         }
@@ -180 +180 @@
         }
 
-        if (pvfs_sys_rmdir(pvfs, name->full_name) == -1) {
+        if (pvfs_sys_rmdir(pvfs, name->full_name, name->allow_override) == -1) {
                 /* some olders systems don't return ENOTEMPTY to rmdir() */
                 if (errno == EEXIST) {

vendor/current/source4/ntvfs/posix/pvfs_notify.c

@@ -110 +110 @@
            would free the request, and the ntvfs modules above us
            could use it, so call it on the next event */
-        event_add_timed(req->ctx->event_ctx, 
+        tevent_add_timer(req->ctx->event_ctx,
                         req, timeval_zero(), pvfs_notify_send_next, req);
 }
@@ -279 +279 @@
         pending->info = info;
 
-        DLIST_ADD_END(f->notify_buffer->pending, pending, struct notify_pending *);
+        DLIST_ADD_END(f->notify_buffer->pending, pending);
 
         /* if the buffer is empty then start waiting */

vendor/current/source4/ntvfs/posix/pvfs_open.c

@@ -74 +74 @@
                                          delete_path, nt_errstr(status)));
                         }
-                        if (pvfs_sys_rmdir(h->pvfs, delete_path) != 0) {
+                        if (pvfs_sys_rmdir(h->pvfs, delete_path, h->name->allow_override) != 0) {
                                 DEBUG(0,("pvfs_dir_handle_destructor: failed to rmdir '%s' - %s\n",
                                          delete_path, strerror(errno)));
@@ -345 +345 @@
                 mode_t mode = pvfs_fileperms(pvfs, attrib);
 
-                if (pvfs_sys_mkdir(pvfs, name->full_name, mode) == -1) {
+                if (pvfs_sys_mkdir(pvfs, name->full_name, mode, name->allow_override) == -1) {
                         return pvfs_map_errno(pvfs,errno);
                 }
@@ -433 +433 @@
 
 cleanup_delete:
-        pvfs_sys_rmdir(pvfs, name->full_name);
+        pvfs_sys_rmdir(pvfs, name->full_name, name->allow_override);
         return status;
 }
@@ -515 +515 @@
                                          delete_path, nt_errstr(status)));
                         }
-                        if (pvfs_sys_unlink(h->pvfs, delete_path) != 0) {
+                        if (pvfs_sys_unlink(h->pvfs, delete_path, h->name->allow_override) != 0) {
                                 DEBUG(0,("pvfs_close: failed to delete '%s' - %s\n",
                                          delete_path, strerror(errno)));
@@ -591 +591 @@
         }
 
-        h = brl_create_handle(mem_ctx, ntvfs, &key);
+        h = brlock_create_handle(mem_ctx, ntvfs, &key);
         NT_STATUS_HAVE_NO_MEMORY(h);
 
@@ -678 +678 @@
 
         /* create the file */
-        fd = pvfs_sys_open(pvfs, name->full_name, flags | O_CREAT | O_EXCL| O_NONBLOCK, mode);
+        fd = pvfs_sys_open(pvfs, name->full_name, flags | O_CREAT | O_EXCL| O_NONBLOCK, mode, name->allow_override);
         if (fd == -1) {
                 return pvfs_map_errno(pvfs, errno);
@@ -718 +718 @@
                 status = pvfs_access_maximal_allowed(pvfs, req, name, 
                                                      &io->generic.out.maximal_access);
-                NT_STATUS_NOT_OK_RETURN(status);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto cleanup_delete;
+                }
         }
 
@@ -857 +859 @@
 cleanup_delete:
         close(fd);
-        pvfs_sys_unlink(pvfs, name->full_name);
+        pvfs_sys_unlink(pvfs, name->full_name, name->allow_override);
         return status;
 }
@@ -1175 +1177 @@
                                              pvfs->oplock_break_timeout,
                                              0);
-                end_time = timeval_current_ofs(0, (pvfs->sharing_violation_delay*4)/5);
+                end_time = timeval_current_ofs_usec((pvfs->sharing_violation_delay*4)/5);
                 end_time = timeval_min(final_timeout, &end_time);
         } else {
@@ -1285 +1287 @@
 
         /* what does this bit really mean?? */
-        if (req->ctx->protocol == PROTOCOL_SMB2 &&
+        if (req->ctx->protocol >= PROTOCOL_SMB2_02 &&
             access_mask == SEC_STD_SYNCHRONIZE) {
                 return NT_STATUS_ACCESS_DENIED;
@@ -1503 +1505 @@
          */
         if (create_options & NTCREATEX_OPTIONS_DELETE_ON_CLOSE &&
-            req->ctx->protocol == PROTOCOL_SMB2) {
+            req->ctx->protocol >= PROTOCOL_SMB2_02) {
                 del_on_close = true;
         } else {
@@ -1550 +1552 @@
 
         /* do the actual open */
-        fd = pvfs_sys_open(pvfs, f->handle->name->full_name, flags | O_NONBLOCK, 0);
+        fd = pvfs_sys_open(pvfs, f->handle->name->full_name, flags | O_NONBLOCK, 0, name->allow_override);
         if (fd == -1) {
                 status = pvfs_map_errno(f->pvfs, errno);
@@ -1570 +1572 @@
         f->handle->fd = fd;
 
-        status = brl_count(f->pvfs->brl_context, f->brl_handle, &count);
+        status = brlock_count(f->pvfs->brl_context, f->brl_handle, &count);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(lck);
@@ -1636 +1638 @@
                 if (f->handle->name->st.st_mode != mode &&
                     f->handle->name->dos.attrib != attrib &&
-                    pvfs_sys_fchmod(pvfs, fd, mode) == -1) {
+                    pvfs_sys_fchmod(pvfs, fd, mode, name->allow_override) == -1) {
                         talloc_free(lck);
                         return pvfs_map_errno(pvfs, errno);

vendor/current/source4/ntvfs/posix/pvfs_oplock.c

@@ -33 +33 @@
         struct timeval break_to_level_II;
         struct timeval break_to_none;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
 };
 
@@ -159 +159 @@
 }
 
-static void pvfs_oplock_break_dispatch(struct messaging_context *msg,
+static void pvfs_oplock_break_dispatch(struct imessaging_context *msg,
                                        void *private_data, uint32_t msg_type,
                                        struct server_id src, DATA_BLOB *data)
@@ -170 +170 @@
 
         /* we need to check that this one is for us. See
-           messaging_send_ptr() for the other side of this.
+           imessaging_send_ptr() for the other side of this.
          */
         if (data->length == sizeof(struct opendb_oplock_break)) {
@@ -193 +193 @@
 static int pvfs_oplock_destructor(struct pvfs_oplock *opl)
 {
-        messaging_deregister(opl->msg_ctx, MSG_NTVFS_OPLOCK_BREAK, opl);
+        imessaging_deregister(opl->msg_ctx, MSG_NTVFS_OPLOCK_BREAK, opl);
         return 0;
 }
@@ -229 +229 @@
         opl->msg_ctx    = f->pvfs->ntvfs->ctx->msg_ctx;
 
-        status = messaging_register(opl->msg_ctx,
+        status = imessaging_register(opl->msg_ctx,
                                     opl,
                                     MSG_NTVFS_OPLOCK_BREAK,

vendor/current/source4/ntvfs/posix/pvfs_qfileinfo.c

@@ -103 +103 @@
                         if (strcasecmp_m(eas->eas[i].name.s, 
                                        ealist->eas[j].name) == 0) {
+                                if (ealist->eas[j].value.length == 0) {
+                                        continue;
+                                }
                                 eas->eas[i].value = ealist->eas[j].value;
                                 break;
@@ -135 +138 @@
                 eas->eas[eas->num_eas].flags = 0;
                 eas->eas[eas->num_eas].name.s = ealist->eas[i].name;
+                if (ealist->eas[i].value.length == 0) {
+                        continue;
+                }
                 eas->eas[eas->num_eas].value = ealist->eas[i].value;
                 eas->num_eas++;
@@ -150 +156 @@
 {
         switch (info->generic.level) {
-        case RAW_FILEINFO_GENERIC:
-                return NT_STATUS_INVALID_LEVEL;
-
         case RAW_FILEINFO_GETATTR:
                 info->getattr.out.attrib     = name->dos.attrib;
@@ -226 +229 @@
         case RAW_FILEINFO_NAME_INFO:
         case RAW_FILEINFO_NAME_INFORMATION:
-                if (req->ctx->protocol == PROTOCOL_SMB2) {
+                if (req->ctx->protocol >= PROTOCOL_SMB2_02) {
                         /* strange that SMB2 doesn't have this */
                         return NT_STATUS_NOT_SUPPORTED;
@@ -334 +337 @@
                 NT_STATUS_HAVE_NO_MEMORY(info->all_info2.out.fname.s);
                 return NT_STATUS_OK;
+
+        case RAW_FILEINFO_GENERIC:
+        case RAW_FILEINFO_UNIX_BASIC:
+        case RAW_FILEINFO_UNIX_INFO2:
+        case RAW_FILEINFO_UNIX_LINK:
+                return NT_STATUS_INVALID_LEVEL;
         }
 

vendor/current/source4/ntvfs/posix/pvfs_read.c

@@ -60 +60 @@
 
         maxcnt = rd->readx.in.maxcnt;
-        if (maxcnt > 2*UINT16_MAX && req->ctx->protocol < PROTOCOL_SMB2) {
+        if (maxcnt > 2*UINT16_MAX && req->ctx->protocol < PROTOCOL_SMB2_02) {
                 DEBUG(3,(__location__ ": Invalid SMB maxcnt 0x%x\n", maxcnt));
                 return NT_STATUS_INVALID_PARAMETER;
@@ -97 +97 @@
 
         /* only SMB2 honors mincnt */
-        if (req->ctx->protocol == PROTOCOL_SMB2) {
+        if (req->ctx->protocol >= PROTOCOL_SMB2_02) {
                 if (rd->readx.in.mincnt > ret ||
                     (ret == 0 && maxcnt > 0)) {

vendor/current/source4/ntvfs/posix/pvfs_rename.c

@@ -38 +38 @@
         NTSTATUS status;
 
-        if (pvfs_sys_rename(pvfs, name1->full_name, name2) == -1) {
+        if (pvfs_sys_rename(pvfs, name1->full_name, name2,
+                            name1->allow_override) == -1) {
                 return pvfs_map_errno(pvfs, errno);
         }
@@ -625 +626 @@
                 status = pvfs_access_check_parent(pvfs, req, name2, SEC_DIR_ADD_FILE);
                 NT_STATUS_NOT_OK_RETURN(status);
-                return pvfs_copy_file(pvfs, name1, name2);
+                return pvfs_copy_file(pvfs, name1, name2, name1->allow_override && name2->allow_override);
 
         case RENAME_FLAG_MOVE_CLUSTER_INFORMATION:

vendor/current/source4/ntvfs/posix/pvfs_resolve.c

@@ -519 +519 @@
         (*name)->exists = false;
         (*name)->stream_exists = false;
+        (*name)->allow_override = false;
 
         if (!(pvfs->fs_attribs & FS_ATTR_NAMED_STREAMS)) {
@@ -525 +526 @@
 
         /* SMB2 doesn't allow a leading slash */
-        if (req->ctx->protocol == PROTOCOL_SMB2 &&
+        if (req->ctx->protocol >= PROTOCOL_SMB2_02 &&
             *cifs_name == '\\') {
                 return NT_STATUS_INVALID_PARAMETER;
@@ -631 +632 @@
         (*name)->stream_name = NULL;
         (*name)->stream_id = 0;
+        (*name)->allow_override = false;
 
         status = pvfs_fill_dos_info(pvfs, *name, flags, -1);
@@ -693 +695 @@
         if (h->have_opendb_entry) {
                 struct odb_lock *lck;
-                char *name = NULL;
+                const char *name = NULL;
 
                 lck = odb_lock(h, h->pvfs->odb_context, &h->odb_locking_key);
@@ -704 +706 @@
                 }
 
-                status = odb_get_path(lck, (const char **) &name);
+                status = odb_get_path(lck, &name);
                 if (NT_STATUS_IS_OK(status)) {
                         /*
@@ -718 +720 @@
                                 char *new_orig;
                                 char *delim;
+                                char *full_name = discard_const_p(char, name);
 
                                 delim = strrchr(name, '/');
@@ -746 +749 @@
                                 talloc_free(h->name->original_name);
                                 talloc_free(h->name->full_name);
-                                h->name->full_name = talloc_steal(h->name, name);
+                                h->name->full_name = talloc_steal(h->name, full_name);
                                 h->name->original_name = new_orig;
                         }
@@ -816 +819 @@
         (*name)->stream_name = NULL;
         (*name)->stream_id = 0;
+        (*name)->allow_override = false;
 
         status = pvfs_fill_dos_info(pvfs, *name, PVFS_RESOLVE_NO_OPENDB, -1);

vendor/current/source4/ntvfs/posix/pvfs_search.c

@@ -62 +62 @@
         if (search->handle == INVALID_SEARCH_HANDLE) return;
         talloc_free(search->te);
-        search->te = event_add_timed(ev, search, 
+        search->te = tevent_add_timer(ev, search,
                                      timeval_current_ofs(search->pvfs->search.inactivity_time, 0), 
                                      pvfs_search_timer, search);
@@ -222 +222 @@
 
         case RAW_SEARCH_DATA_GENERIC:
-                break;
+        case RAW_SEARCH_DATA_UNIX_INFO:
+        case RAW_SEARCH_DATA_UNIX_INFO2:
+                return NT_STATUS_INVALID_LEVEL;
         }
 

vendor/current/source4/ntvfs/posix/pvfs_setfileinfo.c

@@ -131 +131 @@
         /* renames are only allowed within a directory */
         if (strchr_m(info->rename_information.in.new_name, '\\') &&
-            (req->ctx->protocol != PROTOCOL_SMB2)) {
+            (req->ctx->protocol < PROTOCOL_SMB2_02)) {
                 return NT_STATUS_NOT_SUPPORTED;
         }
@@ -144 +144 @@
            but I suspect it is just uninitialised memory */
         if (info->rename_information.in.root_fid != 0 && 
-            (req->ctx->protocol != PROTOCOL_SMB2)) {
+            (req->ctx->protocol < PROTOCOL_SMB2_02)) {
                 return NT_STATUS_INVALID_PARAMETER;
         }
 
         /* construct the fully qualified windows name for the new file name */
-        if (req->ctx->protocol == PROTOCOL_SMB2) {
+        if (req->ctx->protocol >= PROTOCOL_SMB2_02) {
                 /* SMB2 sends the full path of the new name */
                 new_name = talloc_asprintf(req, "\\%s", info->rename_information.in.new_name);
@@ -368 +368 @@
 
         case RAW_SFILEINFO_EA_SET:
-                return pvfs_setfileinfo_ea_set(pvfs, h->name, h->fd, 
+                return pvfs_setfileinfo_ea_set(pvfs, h->name, h->fd,
                                                info->ea_set.in.num_eas,
                                                info->ea_set.in.eas);
@@ -420 +420 @@
                 h->position = info->position_information.in.position;
                 break;
+
+        case RAW_SFILEINFO_FULL_EA_INFORMATION:
+                return pvfs_setfileinfo_ea_set(pvfs, h->name, h->fd,
+                                info->full_ea_information.in.eas.num_eas,
+                                info->full_ea_information.in.eas.eas);
 
         case RAW_SFILEINFO_MODE_INFORMATION:
@@ -535 +540 @@
                 mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
                 if (!(h->name->dos.attrib & FILE_ATTRIBUTE_DIRECTORY)) {
-                        if (pvfs_sys_fchmod(pvfs, h->fd, mode) == -1) {
+                        if (pvfs_sys_fchmod(pvfs, h->fd, mode, h->name->allow_override) == -1) {
                                 return pvfs_map_errno(pvfs, errno);
                         }
@@ -860 +865 @@
         if (newstats.dos.attrib != name->dos.attrib) {
                 mode_t mode = pvfs_fileperms(pvfs, newstats.dos.attrib);
-                if (pvfs_sys_chmod(pvfs, name->full_name, mode) == -1) {
+                if (pvfs_sys_chmod(pvfs, name->full_name, mode, name->allow_override) == -1) {
                         return pvfs_map_errno(pvfs, errno);
                 }

vendor/current/source4/ntvfs/posix/pvfs_sys.c

@@ -197 +197 @@
                 return NULL;
         }
+
         ctx->old_wd = talloc_strdup(ctx, cwd);
+        free(cwd);
+
         if (ctx->old_wd == NULL) {
-                free(cwd);
                 talloc_free(ctx);
                 return NULL;
@@ -257 +259 @@
   wrap open for system override
 */
-int pvfs_sys_open(struct pvfs_state *pvfs, const char *filename, int flags, mode_t mode)
+int pvfs_sys_open(struct pvfs_state *pvfs, const char *filename, int flags, mode_t mode, bool allow_override)
 {
         int fd, ret;
@@ -268 +270 @@
         fd = open(filename, flags, mode);
         if (fd != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return fd;
@@ -367 +369 @@
   wrap unlink for system override
 */
-int pvfs_sys_unlink(struct pvfs_state *pvfs, const char *filename)
+int pvfs_sys_unlink(struct pvfs_state *pvfs, const char *filename, bool allow_override)
 {
         int ret;
@@ -377 +379 @@
         ret = unlink(filename);
         if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return ret;
@@ -406 +408 @@
 {
         int fd = open(path, PVFS_NOFOLLOW | O_RDONLY);
+        int posix_errno = errno;
         if (fd != -1) {
                 close(fd);
                 return false;
         }
-        return (errno == ELOOP);
+
+#if defined(ENOTSUP) && defined(OSF1)
+        /* handle special Tru64 errno */
+        if (errno == ENOTSUP) {
+                posix_errno = ELOOP;
+        }
+#endif /* ENOTSUP */
+
+#ifdef EFTYPE
+        /* fix broken NetBSD errno */
+        if (errno == EFTYPE) {
+                posix_errno = ELOOP;
+        }
+#endif /* EFTYPE */
+
+        /* fix broken FreeBSD errno */
+        if (errno == EMLINK) {
+                posix_errno = ELOOP;
+        }
+
+        return (posix_errno == ELOOP);
 }
 
@@ -416 +439 @@
   wrap rename for system override
 */
-int pvfs_sys_rename(struct pvfs_state *pvfs, const char *name1, const char *name2)
+int pvfs_sys_rename(struct pvfs_state *pvfs, const char *name1, const char *name2, bool allow_override)
 {
         int ret;
@@ -426 +449 @@
         ret = rename(name1, name2);
         if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return ret;
@@ -481 +504 @@
   wrap mkdir for system override
 */
-int pvfs_sys_mkdir(struct pvfs_state *pvfs, const char *dirname, mode_t mode)
+int pvfs_sys_mkdir(struct pvfs_state *pvfs, const char *dirname, mode_t mode, bool allow_override)
 {
         int ret;
@@ -491 +514 @@
         ret = mkdir(dirname, mode);
         if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return ret;
@@ -513 +536 @@
         if (ret == -1) {
                 rmdir(dirname);
-                talloc_free(ctx);
-                errno = saved_errno;
-                return -1;
-        }
-
-        talloc_free(ctx);
-        return ret;
-}
-
-
-/*
-  wrap rmdir for system override
-*/
-int pvfs_sys_rmdir(struct pvfs_state *pvfs, const char *dirname)
-{
-        int ret;
-        struct pvfs_sys_ctx *ctx;
-        int saved_errno, orig_errno;
-
-        orig_errno = errno;
-
-        ret = rmdir(dirname);
-        if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
-            errno != EACCES) {
-                return ret;
-        }
-
-        saved_errno = errno;
-
-        ctx = pvfs_sys_pushdir(pvfs, &dirname);
-        if (ctx == NULL) {
-                errno = saved_errno;
-                return -1;
-        }
-
-        ret = rmdir(dirname);
-        if (ret == -1) {
                 talloc_free(ctx);
                 errno = saved_errno;
@@ -561 +546 @@
 }
 
-/*
-  wrap fchmod for system override
-*/
-int pvfs_sys_fchmod(struct pvfs_state *pvfs, int fd, mode_t mode)
+
+/*
+  wrap rmdir for system override
+*/
+int pvfs_sys_rmdir(struct pvfs_state *pvfs, const char *dirname, bool allow_override)
 {
         int ret;
@@ -572 +558 @@
         orig_errno = errno;
 
-        ret = fchmod(fd, mode);
+        ret = rmdir(dirname);
         if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return ret;
@@ -581 +567 @@
         saved_errno = errno;
 
-        ctx = pvfs_sys_pushdir(pvfs, NULL);
-        if (ctx == NULL) {
-                errno = saved_errno;
-                return -1;
-        }
-
-        ret = fchmod(fd, mode);
+        ctx = pvfs_sys_pushdir(pvfs, &dirname);
+        if (ctx == NULL) {
+                errno = saved_errno;
+                return -1;
+        }
+
+        ret = rmdir(dirname);
         if (ret == -1) {
                 talloc_free(ctx);
@@ -599 +585 @@
 }
 
-
-/*
-  wrap chmod for system override
-*/
-int pvfs_sys_chmod(struct pvfs_state *pvfs, const char *filename, mode_t mode)
+/*
+  wrap fchmod for system override
+*/
+int pvfs_sys_fchmod(struct pvfs_state *pvfs, int fd, mode_t mode, bool allow_override)
 {
         int ret;
@@ -611 +596 @@
         orig_errno = errno;
 
-        ret = chmod(filename, mode);
+        ret = fchmod(fd, mode);
         if (ret != -1 ||
-            !(pvfs->flags & PVFS_FLAG_PERM_OVERRIDE) ||
+            !allow_override ||
             errno != EACCES) {
                 return ret;
@@ -620 +605 @@
         saved_errno = errno;
 
-        ctx = pvfs_sys_pushdir(pvfs, &filename);
-        if (ctx == NULL) {
-                errno = saved_errno;
-                return -1;
-        }
-
-        ret = chmod(filename, mode);
+        ctx = pvfs_sys_pushdir(pvfs, NULL);
+        if (ctx == NULL) {
+                errno = saved_errno;
+                return -1;
+        }
+
+        ret = fchmod(fd, mode);
         if (ret == -1) {
                 talloc_free(ctx);
@@ -637 +622 @@
         return ret;
 }
+
+
+/*
+  wrap chmod for system override
+*/
+int pvfs_sys_chmod(struct pvfs_state *pvfs, const char *filename, mode_t mode, bool allow_override)
+{
+        int ret;
+        struct pvfs_sys_ctx *ctx;
+        int saved_errno, orig_errno;
+
+        orig_errno = errno;
+
+        ret = chmod(filename, mode);
+        if (ret != -1 ||
+            !allow_override ||
+            errno != EACCES) {
+                return ret;
+        }
+
+        saved_errno = errno;
+
+        ctx = pvfs_sys_pushdir(pvfs, &filename);
+        if (ctx == NULL) {
+                errno = saved_errno;
+                return -1;
+        }
+
+        ret = chmod(filename, mode);
+        if (ret == -1) {
+                talloc_free(ctx);
+                errno = saved_errno;
+                return -1;
+        }
+
+        talloc_free(ctx);
+        errno = orig_errno;
+        return ret;
+}

vendor/current/source4/ntvfs/posix/pvfs_unlink.c

@@ -124 +124 @@
 
         /* finally try the actual unlink */
-        if (pvfs_sys_unlink(pvfs, name->full_name) == -1) {
+        if (pvfs_sys_unlink(pvfs, name->full_name, name->allow_override) == -1) {
                 status = pvfs_map_errno(pvfs, errno);
         }

vendor/current/source4/ntvfs/posix/pvfs_util.c

@@ -41 +41 @@
 {
         NTSTATUS status;
-        status = map_nt_error_from_unix(unix_errno);
+        status = map_nt_error_from_unix_common(unix_errno);
         DEBUG(10,(__location__ " mapped unix errno %d -> %s\n", unix_errno, nt_errstr(status)));
         return status;
@@ -91 +91 @@
 NTSTATUS pvfs_copy_file(struct pvfs_state *pvfs,
                         struct pvfs_filename *name1, 
-                        struct pvfs_filename *name2)
+                        struct pvfs_filename *name2,
+                        bool allow_override)
 {
         int fd1, fd2;
@@ -103 +104 @@
         }
 
-        fd1 = pvfs_sys_open(pvfs, name1->full_name, O_RDONLY, 0);
+        fd1 = pvfs_sys_open(pvfs, name1->full_name, O_RDONLY, 0, allow_override);
         if (fd1 == -1) {
                 talloc_free(buf);
@@ -109 +110 @@
         }
 
-        fd2 = pvfs_sys_open(pvfs, name2->full_name, O_CREAT|O_EXCL|O_WRONLY, 0);
+        fd2 = pvfs_sys_open(pvfs, name2->full_name, O_CREAT|O_EXCL|O_WRONLY, 0, allow_override);
         if (fd2 == -1) {
                 close(fd1);
@@ -134 +135 @@
                         close(fd2);
                         talloc_free(buf);
-                        pvfs_sys_unlink(pvfs, name2->full_name);
+                        pvfs_sys_unlink(pvfs, name2->full_name, allow_override);
                         if (ret2 == -1) {
                                 return pvfs_map_errno(pvfs, errno);
@@ -146 +147 @@
 
         mode = pvfs_fileperms(pvfs, name1->dos.attrib);
-        if (pvfs_sys_fchmod(pvfs, fd2, mode) == -1) {
+        if (pvfs_sys_fchmod(pvfs, fd2, mode, allow_override) == -1) {
                 status = pvfs_map_errno(pvfs, errno);
                 close(fd2);
-                pvfs_sys_unlink(pvfs, name2->full_name);
+                pvfs_sys_unlink(pvfs, name2->full_name, allow_override);
                 return status;
         }
@@ -159 +160 @@
         if (!NT_STATUS_IS_OK(status)) {
                 close(fd2);
-                pvfs_sys_unlink(pvfs, name2->full_name);
+                pvfs_sys_unlink(pvfs, name2->full_name, allow_override);
                 return status;
         }

vendor/current/source4/ntvfs/posix/pvfs_wait.c

@@ -34 +34 @@
         void *private_data;
         int msg_type;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         struct tevent_context *ev;
         struct ntvfs_request *req;
@@ -57 +57 @@
   receive a completion message for a wait
 */
-static void pvfs_wait_dispatch(struct messaging_context *msg,
+static void pvfs_wait_dispatch(struct imessaging_context *msg,
                                void *private_data, uint32_t msg_type,
                                struct server_id src, DATA_BLOB *data)
@@ -67 +67 @@
 
         /* we need to check that this one is for us. See
-           messaging_send_ptr() for the other side of this.
+           imessaging_send_ptr() for the other side of this.
          */
         if (data->length == sizeof(void *)) {
@@ -117 +117 @@
 {
         if (pwait->msg_type != -1) {
-                messaging_deregister(pwait->msg_ctx, pwait->msg_type, pwait);
+                imessaging_deregister(pwait->msg_ctx, pwait->msg_type, pwait);
         }
         DLIST_REMOVE(pwait->pvfs->wait_list, pwait);
@@ -157 +157 @@
         if (!timeval_is_zero(&end_time)) {
                 /* setup a timer */
-                event_add_timed(pwait->ev, pwait, end_time, pvfs_wait_timeout, pwait);
+                tevent_add_timer(pwait->ev, pwait, end_time, pvfs_wait_timeout, pwait);
         }
 
@@ -163 +163 @@
            type */
         if (msg_type != -1) {
-                messaging_register(pwait->msg_ctx,
+                imessaging_register(pwait->msg_ctx,
                                    pwait,
                                    msg_type,

vendor/current/source4/ntvfs/posix/pvfs_write.c

@@ -65 +65 @@
         }
 
-        tv = timeval_current_ofs(0, pvfs->writetime_delay);
+        tv = timeval_current_ofs_usec(pvfs->writetime_delay);
 
         h->write_time.update_triggered = true;
         h->write_time.update_on_close = true;
-        h->write_time.update_event = event_add_timed(pvfs->ntvfs->ctx->event_ctx,
+        h->write_time.update_event = tevent_add_timer(pvfs->ntvfs->ctx->event_ctx,
                                                      h, tv,
                                                      pvfs_write_time_update_handler,
                                                      h);
         if (!h->write_time.update_event) {
-                DEBUG(0,("Failed event_add_timed\n"));
+                DEBUG(0,("Failed tevent_add_timer\n"));
         }
 }

vendor/current/source4/ntvfs/posix/pvfs_xattr.c

@@ -25 +25 @@
 #include "librpc/gen_ndr/ndr_xattr.h"
 #include "param/param.h"
+#include "ntvfs/posix/posix_eadb_proto.h"
 
 /*
@@ -82 +83 @@
 {
         if (pvfs->ea_db) {
-                return delete_xattr_tdb(pvfs, attr_name, fname, fd);
+                return delete_posix_eadb(pvfs, attr_name, fname, fd);
         }
         return delete_xattr_system(pvfs, attr_name, fname, fd);
@@ -93 +94 @@
 {
         if (pvfs->ea_db) {
-                return unlink_xattr_tdb(pvfs, fname);
+                return unlink_posix_eadb(pvfs, fname);
         }
         return unlink_xattr_system(pvfs, fname);
@@ -284 +285 @@
         NTSTATUS status;
         ZERO_STRUCTP(eas);
+
+        if (name->stream_name) {
+                /* We don't support EAs on streams */
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+
         if (!(pvfs->flags & PVFS_FLAG_XATTR_ENABLE)) {
                 return NT_STATUS_OK;

vendor/current/source4/ntvfs/posix/python/pyxattr_native.c

@@ -22 +22 @@
 #include "includes.h"
 #include "librpc/ndr/libndr.h"
-#include "lib/util/wrap_xattr.h"
+#include "system/filesys.h"
+
+void initxattr_native(void);
 
 static PyObject *py_is_xattr_supported(PyObject *self)
@@ -37 +39 @@
         char *filename, *attribute;
         int ret = 0;
-        int blobsize;
+        Py_ssize_t blobsize;
         DATA_BLOB blob;
 
@@ -45 +47 @@
 
         blob.length = blobsize;
-        ret = wrap_setxattr(filename, attribute, blob.data, blob.length, 0);
+        ret = setxattr(filename, attribute, blob.data, blob.length, 0);
         if( ret < 0 ) {
                 if (errno == ENOTSUP) {
@@ -67 +69 @@
                 return NULL;
         mem_ctx = talloc_new(NULL);
-        len = wrap_getxattr(filename,attribute,NULL,0);
+        len = getxattr(filename,attribute,NULL,0);
         if( len < 0 ) {
                 if (errno == ENOTSUP) {
@@ -79 +81 @@
         /* check length ... */
         buf = talloc_zero_array(mem_ctx, char, len);
-        len = wrap_getxattr(filename, attribute, buf, len);
+        len = getxattr(filename, attribute, buf, len);
         if( len < 0 ) {
                 if (errno == ENOTSUP) {
@@ -97 +99 @@
         { "wrap_getxattr", (PyCFunction)py_wrap_getxattr, METH_VARARGS,
                 "wrap_getxattr(filename,attribute) -> blob\n"
-                "Retreive given attribute on the given file." },
+                "Retrieve given attribute on the given file." },
         { "wrap_setxattr", (PyCFunction)py_wrap_setxattr, METH_VARARGS,
                 "wrap_setxattr(filename,attribute,value)\n"

vendor/current/source4/ntvfs/posix/python/pyxattr_tdb.c

@@ -21 +21 @@
 #include <Python.h>
 #include "includes.h"
+#include "system/filesys.h"
 #include <tdb.h>
-#include "lib/util/tdb_wrap.h"
+#include "lib/tdb_wrap/tdb_wrap.h"
 #include "librpc/ndr/libndr.h"
-#include "lib/util/wrap_xattr.h"
-#include "ntvfs/posix/vfs_posix.h"
+#include "ntvfs/posix/posix_eadb.h"
 #include "libcli/util/pyerrors.h"
+#include "param/pyparam.h"
+#include "lib/dbwrap/dbwrap.h"
+#include "lib/dbwrap/dbwrap_open.h"
+#include "lib/dbwrap/dbwrap_tdb.h"
+#include "source3/lib/xattr_tdb.h"
+
+void initxattr_tdb(void);
 
 static PyObject *py_is_xattr_supported(PyObject *self)
@@ -37 +44 @@
         char *filename, *attribute, *tdbname;
         DATA_BLOB blob;
-        int blobsize;
-        NTSTATUS status;
+        Py_ssize_t blobsize;
+        int ret;
         TALLOC_CTX *mem_ctx;
-        struct tdb_wrap *eadb;
+        struct loadparm_context *lp_ctx;
+        struct db_context *eadb = NULL;
+        struct file_id id;
+        struct stat sbuf;
 
         if (!PyArg_ParseTuple(args, "ssss#", &tdbname, &filename, &attribute, 
@@ -48 +58 @@
         blob.length = blobsize;
         mem_ctx = talloc_new(NULL);
-        eadb = tdb_wrap_open(mem_ctx, tdbname, 50000,
-                                TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+
+        lp_ctx = py_default_loadparm_context(mem_ctx);
+        eadb = db_open_tdb(mem_ctx, tdbname, 50000,
+                           lpcfg_tdb_flags(lp_ctx, TDB_DEFAULT),
+                           O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_2,
+                           DBWRAP_FLAG_NONE);
 
         if (eadb == NULL) {
@@ -56 +70 @@
                 return NULL;
         }
-        status = push_xattr_blob_tdb_raw(eadb, mem_ctx, attribute, filename, -1,
-                                                                         &blob);
-        if (!NT_STATUS_IS_OK(status)) {
-                PyErr_FromNTSTATUS(status);
+
+        ret = stat(filename, &sbuf);
+        if (ret < 0) {
+                PyErr_SetFromErrno(PyExc_IOError);
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        ZERO_STRUCT(id);
+        id.devid = sbuf.st_dev;
+        id.inode = sbuf.st_ino;
+
+        ret = xattr_tdb_setattr(eadb, &id, attribute, blob.data, blob.length, 0);
+        if (ret < 0) {
+                PyErr_SetFromErrno(PyExc_TypeError);
                 talloc_free(mem_ctx);
                 return NULL;
@@ -71 +96 @@
         char *filename, *attribute, *tdbname;
         TALLOC_CTX *mem_ctx;
+        struct loadparm_context *lp_ctx;
         DATA_BLOB blob;
-        PyObject *ret;
-        NTSTATUS status;
-        struct tdb_wrap *eadb = NULL;
+        PyObject *ret_obj;
+        int ret;
+        ssize_t xattr_size;
+        struct db_context *eadb = NULL;
+        struct file_id id;
+        struct stat sbuf;
 
         if (!PyArg_ParseTuple(args, "sss", &tdbname, &filename, &attribute))
@@ -80 +109 @@
 
         mem_ctx = talloc_new(NULL);
-        eadb = tdb_wrap_open(mem_ctx, tdbname, 50000,
-                                TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+
+        lp_ctx = py_default_loadparm_context(mem_ctx);
+        eadb = db_open_tdb(mem_ctx, tdbname, 50000,
+                           lpcfg_tdb_flags(lp_ctx, TDB_DEFAULT),
+                           O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_2,
+                           DBWRAP_FLAG_NONE);
+
         if (eadb == NULL) {
                 PyErr_SetFromErrno(PyExc_IOError);
@@ -87 +121 @@
                 return NULL;
         }
-        status = pull_xattr_blob_tdb_raw(eadb, mem_ctx, attribute, filename, 
-                                                                         -1, 100, &blob);
-        if (!NT_STATUS_IS_OK(status) || blob.length < 0) {
-                PyErr_FromNTSTATUS(status);
+
+        ret = stat(filename, &sbuf);
+        if (ret < 0) {
+                PyErr_SetFromErrno(PyExc_IOError);
                 talloc_free(mem_ctx);
                 return NULL;
         }
-        ret = PyString_FromStringAndSize((char *)blob.data, blob.length);
+
+        ZERO_STRUCT(id);
+        id.devid = sbuf.st_dev;
+        id.inode = sbuf.st_ino;
+
+        xattr_size = xattr_tdb_getattr(eadb, mem_ctx, &id, attribute, &blob);
+        if (xattr_size < 0) {
+                PyErr_SetFromErrno(PyExc_TypeError);
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        ret_obj = PyString_FromStringAndSize((char *)blob.data, xattr_size);
         talloc_free(mem_ctx);
-        return ret;
+        return ret_obj;
 }
 
@@ -102 +147 @@
         { "wrap_getxattr", (PyCFunction)py_wrap_getxattr, METH_VARARGS,
                 "wrap_getxattr(filename,attribute) -> blob\n"
-                "Retreive given attribute on the given file." },
+                "Retrieve given attribute on the given file." },
         { "wrap_setxattr", (PyCFunction)py_wrap_setxattr, METH_VARARGS,
                 "wrap_setxattr(filename,attribute,value)\n"

vendor/current/source4/ntvfs/posix/vfs_posix.c

@@ -28 +28 @@
 #include "librpc/gen_ndr/security.h"
 #include <tdb.h>
-#include "lib/util/tdb_wrap.h"
+#include "lib/tdb_wrap/tdb_wrap.h"
 #include "libcli/security/security.h"
 #include "lib/events/events.h"
@@ -39 +39 @@
 {
         struct share_config *scfg = pvfs->ntvfs->ctx->config;
-        const char *eadb;
+        char *eadb;
+        char *xattr_backend;
         bool def_perm_override = false;
 
@@ -114 +115 @@
                 FS_ATTR_CASE_SENSITIVE_SEARCH | 
                 FS_ATTR_CASE_PRESERVED_NAMES |
-                FS_ATTR_UNICODE_ON_DISK |
-                FS_ATTR_SPARSE_FILES;
+                FS_ATTR_UNICODE_ON_DISK;
 
         /* allow xattrs to be stored in a external tdb */
-        eadb = share_string_option(scfg, PVFS_EADB, NULL);
+        eadb = share_string_option(pvfs, scfg, PVFS_EADB, NULL);
         if (eadb != NULL) {
-                pvfs->ea_db = tdb_wrap_open(pvfs, eadb, 50000,  
-                                            TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
+                pvfs->ea_db = tdb_wrap_open(
+                        pvfs, eadb, 50000,
+                        lpcfg_tdb_flags(pvfs->ntvfs->ctx->lp_ctx, TDB_DEFAULT),
+                        O_RDWR|O_CREAT, 0600);
+                TALLOC_FREE(eadb);
                 if (pvfs->ea_db != NULL) {
                         pvfs->flags |= PVFS_FLAG_XATTR_ENABLE;
@@ -147 +150 @@
 
         /* enable an ACL backend */
-        pvfs->acl_ops = pvfs_acl_backend_byname(share_string_option(scfg, PVFS_ACL, "xattr"));
+        xattr_backend = share_string_option(pvfs, scfg, PVFS_ACL, "xattr");
+        pvfs->acl_ops = pvfs_acl_backend_byname(xattr_backend);
+        TALLOC_FREE(xattr_backend);
 }
 
@@ -213 +218 @@
          *       but currently we don't have a lp_ctx there
          */
-        status = pvfs_acl_init(ntvfs->ctx->lp_ctx);
+        status = pvfs_acl_init();
         NT_STATUS_NOT_OK_RETURN(status);
 
@@ -220 +225 @@
 
         /* for simplicity of path construction, remove any trailing slash now */
-        base_directory = talloc_strdup(pvfs, share_string_option(ntvfs->ctx->config, SHARE_PATH, ""));
+        base_directory = share_string_option(pvfs, ntvfs->ctx->config, SHARE_PATH, "");
         NT_STATUS_HAVE_NO_MEMORY(base_directory);
         if (strcmp(base_directory, "/") != 0) {
@@ -250 +255 @@
         ntvfs->private_data = pvfs;
 
-        pvfs->brl_context = brl_init(pvfs, 
+        pvfs->brl_context = brlock_init(pvfs, 
                                      pvfs->ntvfs->ctx->server_id,
                                      pvfs->ntvfs->ctx->lp_ctx,
@@ -271 +276 @@
                                            pvfs->ntvfs->ctx->config);
 
-        pvfs->wbc_ctx = wbc_init(pvfs,
-                                 pvfs->ntvfs->ctx->msg_ctx,
-                                 pvfs->ntvfs->ctx->event_ctx);
-        if (pvfs->wbc_ctx == NULL) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
         /* allocate the search handle -> ptr tree */
         pvfs->search.idtree = idr_init(pvfs);
@@ -373 +371 @@
         
         /* fill in all the operations */
-        ops.connect = pvfs_connect;
-        ops.disconnect = pvfs_disconnect;
-        ops.unlink = pvfs_unlink;
-        ops.chkpath = pvfs_chkpath;
-        ops.qpathinfo = pvfs_qpathinfo;
-        ops.setpathinfo = pvfs_setpathinfo;
-        ops.open = pvfs_open;
-        ops.mkdir = pvfs_mkdir;
-        ops.rmdir = pvfs_rmdir;
-        ops.rename = pvfs_rename;
-        ops.copy = pvfs_copy;
-        ops.ioctl = pvfs_ioctl;
-        ops.read = pvfs_read;
-        ops.write = pvfs_write;
-        ops.seek = pvfs_seek;
-        ops.flush = pvfs_flush; 
-        ops.close = pvfs_close;
-        ops.exit = pvfs_exit;
-        ops.lock = pvfs_lock;
-        ops.setfileinfo = pvfs_setfileinfo;
-        ops.qfileinfo = pvfs_qfileinfo;
-        ops.fsinfo = pvfs_fsinfo;
-        ops.lpq = pvfs_lpq;
-        ops.search_first = pvfs_search_first;
-        ops.search_next = pvfs_search_next;
-        ops.search_close = pvfs_search_close;
-        ops.trans = pvfs_trans;
-        ops.logoff = pvfs_logoff;
-        ops.async_setup = pvfs_async_setup;
-        ops.cancel = pvfs_cancel;
-        ops.notify = pvfs_notify;
+        ops.connect_fn = pvfs_connect;
+        ops.disconnect_fn = pvfs_disconnect;
+        ops.unlink_fn = pvfs_unlink;
+        ops.chkpath_fn = pvfs_chkpath;
+        ops.qpathinfo_fn = pvfs_qpathinfo;
+        ops.setpathinfo_fn = pvfs_setpathinfo;
+        ops.open_fn = pvfs_open;
+        ops.mkdir_fn = pvfs_mkdir;
+        ops.rmdir_fn = pvfs_rmdir;
+        ops.rename_fn = pvfs_rename;
+        ops.copy_fn = pvfs_copy;
+        ops.ioctl_fn = pvfs_ioctl;
+        ops.read_fn = pvfs_read;
+        ops.write_fn = pvfs_write;
+        ops.seek_fn = pvfs_seek;
+        ops.flush_fn = pvfs_flush;
+        ops.close_fn = pvfs_close;
+        ops.exit_fn = pvfs_exit;
+        ops.lock_fn = pvfs_lock;
+        ops.setfileinfo_fn = pvfs_setfileinfo;
+        ops.qfileinfo_fn = pvfs_qfileinfo;
+        ops.fsinfo_fn = pvfs_fsinfo;
+        ops.lpq_fn = pvfs_lpq;
+        ops.search_first_fn = pvfs_search_first;
+        ops.search_next_fn = pvfs_search_next;
+        ops.search_close_fn = pvfs_search_close;
+        ops.trans_fn = pvfs_trans;
+        ops.logoff_fn = pvfs_logoff;
+        ops.async_setup_fn = pvfs_async_setup;
+        ops.cancel_fn = pvfs_cancel;
+        ops.notify_fn = pvfs_notify;
 
         /* register ourselves with the NTVFS subsystem. We register

vendor/current/source4/ntvfs/posix/vfs_posix.h

@@ -48 +48 @@
         struct odb_context *odb_context;
         struct notify_context *notify_context;
-        struct wbc_context *wbc_ctx;
 
         /* a list of pending async requests. Needed to support
@@ -132 +131 @@
         bool exists;          /* true if the base filename exists */
         bool stream_exists;   /* true if the stream exists */
+        bool allow_override;
         struct stat st;
         struct pvfs_dos_fileinfo dos;
@@ -205 +205 @@
         struct brl_handle *brl_handle;
 
-        /* a count of active locks - used to avoid calling brl_close on
+        /* a count of active locks - used to avoid calling brlock_close on
            file close */
         uint64_t lock_count;

vendor/current/source4/ntvfs/posix/wscript_build

@@ -4 +4 @@
         source='pvfs_acl.c',
         autoproto='vfs_acl_proto.h',
-        deps='events',
+        deps='events samba-modules',
         )
 
@@ -32 +32 @@
 
 bld.SAMBA_MODULE('ntvfs_posix',
-        source='vfs_posix.c pvfs_util.c pvfs_search.c pvfs_dirlist.c pvfs_fileinfo.c pvfs_unlink.c pvfs_mkdir.c pvfs_open.c pvfs_read.c pvfs_flush.c pvfs_write.c pvfs_fsinfo.c pvfs_qfileinfo.c pvfs_setfileinfo.c pvfs_rename.c pvfs_resolve.c pvfs_shortname.c pvfs_lock.c pvfs_oplock.c pvfs_wait.c pvfs_seek.c pvfs_ioctl.c pvfs_xattr.c pvfs_streams.c pvfs_notify.c pvfs_sys.c xattr_system.c xattr_tdb.c',
+        source='vfs_posix.c pvfs_util.c pvfs_search.c pvfs_dirlist.c pvfs_fileinfo.c pvfs_unlink.c pvfs_mkdir.c pvfs_open.c pvfs_read.c pvfs_flush.c pvfs_write.c pvfs_fsinfo.c pvfs_qfileinfo.c pvfs_setfileinfo.c pvfs_rename.c pvfs_resolve.c pvfs_shortname.c pvfs_lock.c pvfs_oplock.c pvfs_wait.c pvfs_seek.c pvfs_ioctl.c pvfs_xattr.c pvfs_streams.c pvfs_notify.c pvfs_sys.c xattr_system.c',
         autoproto='vfs_posix_proto.h',
         subsystem='ntvfs',
         init_function='ntvfs_posix_init',
-        deps='NDR_XATTR wrap_xattr ntvfs_common MESSAGING LIBWBCLIENT_OLD pvfs_acl pvfs_aio',
+        deps='NDR_XATTR attr ntvfs_common MESSAGING LIBWBCLIENT_OLD pvfs_acl pvfs_aio posix_eadb',
         internal_module=True
         )
@@ -43 +43 @@
 bld.SAMBA_PYTHON('python_xattr_native',
         source='python/pyxattr_native.c',
-        deps='ndr ldb samdb credentials pyparam_util wrap_xattr attr',
+        deps='ndr ldb samdb samba-credentials pyparam_util attr',
         realname='samba/xattr_native.so'
         )
 
+bld.SAMBA_LIBRARY('posix_eadb',
+                  source='posix_eadb.c',
+                  deps='tdb tdb-wrap samba-util',
+                  autoproto='posix_eadb_proto.h',
+                  private_library=True)
+
+bld.SAMBA_PYTHON('python_posix_eadb',
+        source='python/pyposix_eadb.c',
+        deps='pyparam_util posix_eadb tdb',
+        realname='samba/posix_eadb.so'
+        )
 
 bld.SAMBA_PYTHON('python_xattr_tdb',
-        source='python/pyxattr_tdb.c xattr_tdb.c',
-        deps='ndr ldb pyparam_util share attr',
+        source='python/pyxattr_tdb.c',
+        deps='pyparam_util xattr_tdb',
         realname='samba/xattr_tdb.so'
         )

vendor/current/source4/ntvfs/posix/xattr_system.c

@@ -22 +22 @@
 #include "includes.h"
 #include "vfs_posix.h"
-#include "../lib/util/wrap_xattr.h"
 
 /*
@@ -44 +43 @@
 again:
         if (fd != -1) {
-                ret = wrap_fgetxattr(fd, attr_name, blob->data, estimated_size);
+                ret = fgetxattr(fd, attr_name, blob->data, estimated_size);
         } else {
-                ret = wrap_getxattr(fname, attr_name, blob->data, estimated_size);
+                ret = getxattr(fname, attr_name, blob->data, estimated_size);
         }
         if (ret == -1 && errno == ERANGE) {
@@ -105 +104 @@
 
         if (fd != -1) {
-                ret = wrap_fsetxattr(fd, attr_name, blob->data, blob->length, 0);
+                ret = fsetxattr(fd, attr_name, blob->data, blob->length, 0);
         } else {
-                ret = wrap_setxattr(fname, attr_name, blob->data, blob->length, 0);
+                ret = setxattr(fname, attr_name, blob->data, blob->length, 0);
         }
         if (ret == -1) {
@@ -126 +125 @@
 
         if (fd != -1) {
-                ret = wrap_fremovexattr(fd, attr_name);
+                ret = fremovexattr(fd, attr_name);
         } else {
-                ret = wrap_removexattr(fname, attr_name);
+                ret = removexattr(fname, attr_name);
         }
         if (ret == -1) {