Changeset 988 for vendor/current/source4/ntvfs

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

Files:

• cifs/vfs_cifs.c (modified) (14 diffs)
• cifs_posix_cli/svfs_util.c (modified) (3 diffs)
• cifs_posix_cli/vfs_cifs_posix.c (modified) (19 diffs)
• common/brlock.c (modified) (9 diffs)
• common/brlock.h (modified) (2 diffs)
• common/brlock_tdb.c (modified) (33 diffs)
• common/init.c (modified) (1 diff)
• common/notify.c (modified) (28 diffs)
• common/opendb.c (modified) (1 diff)
• common/opendb.h (modified) (1 diff)
• common/opendb_tdb.c (modified) (19 diffs)
• common/wscript_build (modified) (1 diff)
• ipc/ipc_rap.c (modified) (4 diffs)
• ipc/rap_server.c (modified) (1 diff)
• ipc/vfs_ipc.c (modified) (14 diffs)
• nbench/vfs_nbench.c (modified) (21 diffs)
• ntvfs.h (modified) (4 diffs)
• ntvfs_base.c (modified) (4 diffs)
• ntvfs_generic.c (modified) (32 diffs)
• ntvfs_interface.c (modified) (63 diffs)
• posix/posix_eadb.c (added)
• posix/posix_eadb.h (added)
• posix/pvfs_acl.c (modified) (30 diffs)
• posix/pvfs_acl_nfs4.c (modified) (5 diffs)
• posix/pvfs_acl_xattr.c (modified) (1 diff)
• posix/pvfs_dirlist.c (modified) (3 diffs)
• posix/pvfs_fileinfo.c (modified) (1 diff)
• posix/pvfs_fsinfo.c (modified) (1 diff)
• posix/pvfs_ioctl.c (modified) (1 diff)
• posix/pvfs_lock.c (modified) (11 diffs)
• posix/pvfs_mkdir.c (modified) (6 diffs)
• posix/pvfs_notify.c (modified) (2 diffs)
• posix/pvfs_open.c (modified) (14 diffs)
• posix/pvfs_oplock.c (modified) (5 diffs)
• posix/pvfs_qfileinfo.c (modified) (5 diffs)
• posix/pvfs_read.c (modified) (2 diffs)
• posix/pvfs_rename.c (modified) (2 diffs)
• posix/pvfs_resolve.c (modified) (8 diffs)
• posix/pvfs_search.c (modified) (2 diffs)
• posix/pvfs_setfileinfo.c (modified) (6 diffs)
• posix/pvfs_sys.c (modified) (18 diffs)
• posix/pvfs_unlink.c (modified) (1 diff)
• posix/pvfs_util.c (modified) (7 diffs)
• posix/pvfs_wait.c (modified) (6 diffs)
• posix/pvfs_write.c (modified) (1 diff)
• posix/pvfs_xattr.c (modified) (4 diffs)
• posix/python/pyposix_eadb.c (added)
• posix/python/pyxattr_native.c (modified) (6 diffs)
• posix/python/pyxattr_tdb.c (modified) (8 diffs)
• posix/vfs_posix.c (modified) (9 diffs)
• posix/vfs_posix.h (modified) (3 diffs)
• posix/wscript_build (modified) (3 diffs)
• posix/xattr_system.c (modified) (4 diffs)
• posix/xattr_tdb.c (deleted)
• print/vfs_print.c (modified) (2 diffs)
• simple/svfs_util.c (modified) (3 diffs)
• simple/vfs_simple.c (modified) (20 diffs)
• smb2/vfs_smb2.c (modified) (15 diffs)
• sysdep/inotify.c (modified) (7 diffs)
• sysdep/sys_lease.c (modified) (5 diffs)
• sysdep/sys_lease.h (modified) (3 diffs)
• sysdep/sys_lease_linux.c (modified) (3 diffs)
• sysdep/sys_notify.c (modified) (2 diffs)
• sysdep/sys_notify.h (modified) (1 diff)
• sysdep/wscript_build (modified) (1 diff)
• sysdep/wscript_configure (modified) (1 diff)
• unixuid/vfs_unixuid.c (modified) (11 diffs)
• unixuid/wscript_build (modified) (1 diff)
• wscript_build (modified) (5 diffs)

vendor/current/source4/ntvfs/cifs/vfs_cifs.c

@@ -35 +35 @@
 #include "param/param.h"
 #include "libcli/resolve/resolve.h"
+#include "../libcli/smb/smbXcli_base.h"
 
 struct cvfs_file {
@@ -64 +65 @@
 };
 
+NTSTATUS ntvfs_cifs_init(void);
+
 #define CHECK_UPSTREAM_OPEN do { \
-        if (! p->transport->socket->sock) { \
+        if (!smbXcli_conn_is_connected(p->transport->conn)) { \
                 req->async_states->state|=NTVFS_ASYNC_STATE_CLOSE; \
                 return NT_STATUS_CONNECTION_DISCONNECTED; \
@@ -98 +101 @@
 #define CIFS_SHARE              "cifs:share"
 #define CIFS_USE_MACHINE_ACCT   "cifs:use-machine-account"
+#define CIFS_USE_S4U2PROXY      "cifs:use-s4u2proxy"
 #define CIFS_MAP_GENERIC        "cifs:map-generic"
 #define CIFS_MAP_TRANS2         "cifs:map-trans2"
 
 #define CIFS_USE_MACHINE_ACCT_DEFAULT   false
+#define CIFS_USE_S4U2PROXY_DEFAULT      false
 #define CIFS_MAP_GENERIC_DEFAULT        false
 #define CIFS_MAP_TRANS2_DEFAULT         true
@@ -149 +154 @@
         struct cli_credentials *credentials;
         bool machine_account;
+        bool s4u2proxy;
         const char* sharename;
+        TALLOC_CTX *tmp_ctx;
+
+        tmp_ctx = talloc_new(req);
+        if (tmp_ctx == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
 
         switch (tcon->generic.level) {
@@ -162 +174 @@
                 break;
         default:
-                return NT_STATUS_INVALID_LEVEL;
+                status = NT_STATUS_INVALID_LEVEL;
+                goto out;
         }
 
@@ -174 +187 @@
         /* Here we need to determine which server to connect to.
          * For now we use parametric options, type cifs.
-         * Later we will use security=server and auth_server.c.
          */
-        host = share_string_option(scfg, CIFS_SERVER, NULL);
-        user = share_string_option(scfg, CIFS_USER, NULL);
-        pass = share_string_option(scfg, CIFS_PASSWORD, NULL);
-        domain = share_string_option(scfg, CIFS_DOMAIN, NULL);
-        remote_share = share_string_option(scfg, CIFS_SHARE, NULL);
+        host = share_string_option(tmp_ctx, scfg, CIFS_SERVER, NULL);
+        user = share_string_option(tmp_ctx, scfg, CIFS_USER, NULL);
+        pass = share_string_option(tmp_ctx, scfg, CIFS_PASSWORD, NULL);
+        domain = share_string_option(tmp_ctx, scfg, CIFS_DOMAIN, NULL);
+        remote_share = share_string_option(tmp_ctx, scfg, CIFS_SHARE, NULL);
         if (!remote_share) {
                 remote_share = sharename;
@@ -186 +198 @@
 
         machine_account = share_bool_option(scfg, CIFS_USE_MACHINE_ACCT, CIFS_USE_MACHINE_ACCT_DEFAULT);
+        s4u2proxy = share_bool_option(scfg, CIFS_USE_S4U2PROXY, CIFS_USE_S4U2PROXY_DEFAULT);
 
         p = talloc_zero(ntvfs, struct cvfs_private);
         if (!p) {
-                return NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
         }
 
@@ -196 +210 @@
         if (!host) {
                 DEBUG(1,("CIFS backend: You must supply server\n"));
-                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto out;
         } 
         
@@ -203 +218 @@
                 credentials = cli_credentials_init(p);
                 if (!credentials) {
-                        return NT_STATUS_NO_MEMORY;
+                        status = NT_STATUS_NO_MEMORY;
+                        goto out;
                 }
                 cli_credentials_set_conf(credentials, ntvfs->ctx->lp_ctx);
@@ -220 +236 @@
                 status = cli_credentials_set_machine_account(credentials, ntvfs->ctx->lp_ctx);
                 if (!NT_STATUS_IS_OK(status)) {
-                        return status;
+                        goto out;
                 }
         } else if (req->session_info->credentials) {
                 DEBUG(5, ("CIFS backend: Using delegated credentials\n"));
                 credentials = req->session_info->credentials;
+        } else if (s4u2proxy) {
+                struct ccache_container *ccc = NULL;
+                const char *err_str = NULL;
+                int ret;
+                char *impersonate_principal;
+                char *self_service;
+                char *target_service;
+
+                impersonate_principal = talloc_asprintf(req, "%s@%s",
+                                                req->session_info->info->account_name,
+                                                req->session_info->info->domain_name);
+
+                self_service = talloc_asprintf(req, "cifs/%s",
+                                               lpcfg_netbios_name(ntvfs->ctx->lp_ctx));
+
+                target_service = talloc_asprintf(req, "cifs/%s", host);
+
+                DEBUG(5, ("CIFS backend: Using S4U2Proxy credentials\n"));
+
+                credentials = cli_credentials_init(p);
+                cli_credentials_set_conf(credentials, ntvfs->ctx->lp_ctx);
+                if (domain) {
+                        cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
+                }
+                status = cli_credentials_set_machine_account(credentials, ntvfs->ctx->lp_ctx);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto out;
+                }
+                cli_credentials_invalidate_ccache(credentials, CRED_SPECIFIED);
+                cli_credentials_set_impersonate_principal(credentials,
+                                                          impersonate_principal,
+                                                          self_service);
+                cli_credentials_set_target_service(credentials, target_service);
+                ret = cli_credentials_get_ccache(credentials,
+                                                 ntvfs->ctx->event_ctx,
+                                                 ntvfs->ctx->lp_ctx,
+                                                 &ccc,
+                                                 &err_str);
+                if (ret != 0) {
+                        status = NT_STATUS_CROSSREALM_DELEGATION_FAILURE;
+                        DEBUG(1,("S4U2Proxy: cli_credentials_get_ccache() gave: ret[%d] str[%s] - %s\n",
+                                ret, err_str, nt_errstr(status)));
+                        goto out;
+                }
+
         } else {
                 DEBUG(1,("CIFS backend: NO delegated credentials found: You must supply server, user and password or the client must supply delegated credentials\n"));
-                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INTERNAL_ERROR;
+                goto out;
         }
 
@@ -252 +314 @@
                                           ntvfs->ctx->event_ctx);
         status = smb_composite_connect_recv(creq, p);
-        NT_STATUS_NOT_OK_RETURN(status);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto out;
+        }
 
         p->tree = io.out.tree;
@@ -261 +325 @@
 
         ntvfs->ctx->fs_type = talloc_strdup(ntvfs->ctx, "NTFS");
-        NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->fs_type);
+        if (ntvfs->ctx->fs_type == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
         ntvfs->ctx->dev_type = talloc_strdup(ntvfs->ctx, "A:");
-        NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->dev_type);
+        if (ntvfs->ctx->dev_type == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
 
         if (tcon->generic.level == RAW_TCON_TCONX) {
@@ -277 +347 @@
         p->map_trans2 = share_bool_option(scfg, CIFS_MAP_TRANS2, CIFS_MAP_TRANS2_DEFAULT);
 
-        return NT_STATUS_OK;
+        status = NT_STATUS_OK;
+
+out:
+        TALLOC_FREE(tmp_ctx);
+        return status;
 }
 
@@ -1141 +1215 @@
         
         /* fill in all the operations */
-        ops.connect = cvfs_connect;
-        ops.disconnect = cvfs_disconnect;
-        ops.unlink = cvfs_unlink;
-        ops.chkpath = cvfs_chkpath;
-        ops.qpathinfo = cvfs_qpathinfo;
-        ops.setpathinfo = cvfs_setpathinfo;
-        ops.open = cvfs_open;
-        ops.mkdir = cvfs_mkdir;
-        ops.rmdir = cvfs_rmdir;
-        ops.rename = cvfs_rename;
-        ops.copy = cvfs_copy;
-        ops.ioctl = cvfs_ioctl;
-        ops.read = cvfs_read;
-        ops.write = cvfs_write;
-        ops.seek = cvfs_seek;
-        ops.flush = cvfs_flush; 
-        ops.close = cvfs_close;
-        ops.exit = cvfs_exit;
-        ops.lock = cvfs_lock;
-        ops.setfileinfo = cvfs_setfileinfo;
-        ops.qfileinfo = cvfs_qfileinfo;
-        ops.fsinfo = cvfs_fsinfo;
-        ops.lpq = cvfs_lpq;
-        ops.search_first = cvfs_search_first;
-        ops.search_next = cvfs_search_next;
-        ops.search_close = cvfs_search_close;
-        ops.trans = cvfs_trans;
-        ops.logoff = cvfs_logoff;
-        ops.async_setup = cvfs_async_setup;
-        ops.cancel = cvfs_cancel;
-        ops.notify = cvfs_notify;
-        ops.trans2 = cvfs_trans2;
+        ops.connect_fn = cvfs_connect;
+        ops.disconnect_fn = cvfs_disconnect;
+        ops.unlink_fn = cvfs_unlink;
+        ops.chkpath_fn = cvfs_chkpath;
+        ops.qpathinfo_fn = cvfs_qpathinfo;
+        ops.setpathinfo_fn = cvfs_setpathinfo;
+        ops.open_fn = cvfs_open;
+        ops.mkdir_fn = cvfs_mkdir;
+        ops.rmdir_fn = cvfs_rmdir;
+        ops.rename_fn = cvfs_rename;
+        ops.copy_fn = cvfs_copy;
+        ops.ioctl_fn = cvfs_ioctl;
+        ops.read_fn = cvfs_read;
+        ops.write_fn = cvfs_write;
+        ops.seek_fn = cvfs_seek;
+        ops.flush_fn = cvfs_flush;
+        ops.close_fn = cvfs_close;
+        ops.exit_fn = cvfs_exit;
+        ops.lock_fn = cvfs_lock;
+        ops.setfileinfo_fn = cvfs_setfileinfo;
+        ops.qfileinfo_fn = cvfs_qfileinfo;
+        ops.fsinfo_fn = cvfs_fsinfo;
+        ops.lpq_fn = cvfs_lpq;
+        ops.search_first_fn = cvfs_search_first;
+        ops.search_next_fn = cvfs_search_next;
+        ops.search_close_fn = cvfs_search_close;
+        ops.trans_fn = cvfs_trans;
+        ops.logoff_fn = cvfs_logoff;
+        ops.async_setup_fn = cvfs_async_setup;
+        ops.cancel_fn = cvfs_cancel;
+        ops.notify_fn = cvfs_notify;
+        ops.trans2_fn = cvfs_trans2;
 
         /* register ourselves with the NTVFS subsystem. We register

vendor/current/source4/ntvfs/cifs_posix_cli/svfs_util.c

@@ -42 +42 @@
         struct cifspsx_private *p = ntvfs->private_data;
         char *ret;
+        char *name_lower = strlower_talloc(p, name);
 
         if (*name != '\\') {
-                ret = talloc_asprintf(req, "%s/%s", p->connectpath, name);
+                ret = talloc_asprintf(req, "%s/%s", p->connectpath, name_lower);
         } else {
-                ret = talloc_asprintf(req, "%s%s", p->connectpath, name);
+                ret = talloc_asprintf(req, "%s%s", p->connectpath, name_lower);
         }
         all_string_sub(ret, "\\", "/", 0);
-
-        strlower(ret + strlen(p->connectpath));
-
+        talloc_free(name_lower);
         return ret;
 }
@@ -86 +85 @@
         mask = p+1;
 
-        low_mask = talloc_strdup(mem_ctx, mask);
+        low_mask = strlower_talloc(mem_ctx, mask);
         if (!low_mask) { return NULL; }
-        strlower(low_mask);
 
         odir = opendir(dir->unix_dir);
@@ -103 +101 @@
                 }
 
-                low_name = talloc_strdup(mem_ctx, dent->d_name);
+                low_name = strlower_talloc(mem_ctx, dent->d_name);
                 if (!low_name) { continue; }
-                strlower(low_name);
 
                 /* check it matches the wildcard pattern */
-                if (ms_fnmatch(low_mask, low_name, PROTOCOL_NT1) != 0) {
+                if (ms_fnmatch_protocol(low_mask, low_name, PROTOCOL_NT1) != 0) {
                         continue;
                 }

vendor/current/source4/ntvfs/cifs_posix_cli/vfs_cifs_posix.c

@@ -82 +82 @@
         p->ntvfs = ntvfs;
         p->next_search_handle = 0;
-        p->connectpath = talloc_strdup(p, share_string_option(scfg, SHARE_PATH, ""));
+        p->connectpath = share_string_option(p, scfg, SHARE_PATH, "");
         p->open_files = NULL;
         p->search = NULL;
@@ -151 +151 @@
         /* ignoring wildcards ... */
         if (unlink(unix_path) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -180 +180 @@
 
         if (stat(unix_path, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -295 +295 @@
         if (stat(unix_path, &st) == -1) {
                 DEBUG(19,("cifspsx_qpathinfo: file %s errno=%d\n", unix_path, errno));
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
         DEBUG(19,("cifspsx_qpathinfo: file %s, stat done\n", unix_path));
@@ -321 +321 @@
         
         if (fstat(f->fd, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -390 +390 @@
                         if (mkdir(unix_path, 0755) == -1) {
                                 DEBUG(9,("cifspsx_open: mkdir %s errno=%d\n", unix_path, errno));
-                                return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
                         }
                         break;
@@ -396 +396 @@
                         if (mkdir(unix_path, 0755) == -1 && errno != EEXIST) {
                                 DEBUG(9,("cifspsx_open: mkdir %s errno=%d\n", unix_path, errno));
-                                return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
                         }
                         break;
@@ -405 +405 @@
         fd = open(unix_path, flags, 0644);
         if (fd == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -411 +411 @@
                 DEBUG(9,("cifspsx_open: fstat errno=%d\n", errno));
                 close(fd);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -460 +460 @@
 
         if (mkdir(unix_path, 0777) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -479 +479 @@
 
         if (rmdir(unix_path) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -503 +503 @@
 
         if (rename(unix_path1, unix_path2) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
         
@@ -542 +542 @@
                     rd->readx.in.offset);
         if (ret == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -578 +578 @@
                      wr->writex.in.offset);
         if (ret == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
                 
@@ -649 +649 @@
 
         if (close(f->fd) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -739 +739 @@
                 if (ftruncate(f->fd, 
                               info->end_of_file_info.in.size) == -1) {
-                        return map_nt_error_from_unix(errno);
+                        return map_nt_error_from_unix_common(errno);
                 }
                 break;
@@ -785 +785 @@
                         &fs->generic.out.blocks_free, 
                         &fs->generic.out.blocks_total) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -825 +825 @@
 
         if (stat(p->connectpath, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -1062 +1062 @@
 
         /* fill in all the operations */
-        ops.connect = cifspsx_connect;
-        ops.disconnect = cifspsx_disconnect;
-        ops.unlink = cifspsx_unlink;
-        ops.chkpath = cifspsx_chkpath;
-        ops.qpathinfo = cifspsx_qpathinfo;
-        ops.setpathinfo = cifspsx_setpathinfo;
-        ops.open = cifspsx_open;
-        ops.mkdir = cifspsx_mkdir;
-        ops.rmdir = cifspsx_rmdir;
-        ops.rename = cifspsx_rename;
-        ops.copy = cifspsx_copy;
-        ops.ioctl = cifspsx_ioctl;
-        ops.read = cifspsx_read;
-        ops.write = cifspsx_write;
-        ops.seek = cifspsx_seek;
-        ops.flush = cifspsx_flush;      
-        ops.close = cifspsx_close;
-        ops.exit = cifspsx_exit;
-        ops.lock = cifspsx_lock;
-        ops.setfileinfo = cifspsx_setfileinfo;
-        ops.qfileinfo = cifspsx_qfileinfo;
-        ops.fsinfo = cifspsx_fsinfo;
-        ops.lpq = cifspsx_lpq;
-        ops.search_first = cifspsx_search_first;
-        ops.search_next = cifspsx_search_next;
-        ops.search_close = cifspsx_search_close;
-        ops.trans = cifspsx_trans;
-        ops.logoff = cifspsx_logoff;
-        ops.async_setup = cifspsx_async_setup;
-        ops.cancel = cifspsx_cancel;
+        ops.connect_fn = cifspsx_connect;
+        ops.disconnect_fn = cifspsx_disconnect;
+        ops.unlink_fn = cifspsx_unlink;
+        ops.chkpath_fn = cifspsx_chkpath;
+        ops.qpathinfo_fn = cifspsx_qpathinfo;
+        ops.setpathinfo_fn = cifspsx_setpathinfo;
+        ops.open_fn = cifspsx_open;
+        ops.mkdir_fn = cifspsx_mkdir;
+        ops.rmdir_fn = cifspsx_rmdir;
+        ops.rename_fn = cifspsx_rename;
+        ops.copy_fn = cifspsx_copy;
+        ops.ioctl_fn = cifspsx_ioctl;
+        ops.read_fn = cifspsx_read;
+        ops.write_fn = cifspsx_write;
+        ops.seek_fn = cifspsx_seek;
+        ops.flush_fn = cifspsx_flush;
+        ops.close_fn = cifspsx_close;
+        ops.exit_fn = cifspsx_exit;
+        ops.lock_fn = cifspsx_lock;
+        ops.setfileinfo_fn = cifspsx_setfileinfo;
+        ops.qfileinfo_fn = cifspsx_qfileinfo;
+        ops.fsinfo_fn = cifspsx_fsinfo;
+        ops.lpq_fn = cifspsx_lpq;
+        ops.search_first_fn = cifspsx_search_first;
+        ops.search_next_fn = cifspsx_search_next;
+        ops.search_close_fn = cifspsx_search_close;
+        ops.trans_fn = cifspsx_trans;
+        ops.logoff_fn = cifspsx_logoff;
+        ops.async_setup_fn = cifspsx_async_setup;
+        ops.cancel_fn = cifspsx_cancel;
 
         /* register ourselves with the NTVFS subsystem. We register

vendor/current/source4/ntvfs/common/brlock.c

@@ -27 +27 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
 #include "messaging/messaging.h"
 #include "lib/messaging/irpc.h"
@@ -39 +38 @@
   set the brl backend ops
 */
-void brl_set_ops(const struct brlock_ops *new_ops)
+void brlock_set_ops(const struct brlock_ops *new_ops)
 {
         ops = new_ops;
@@ -46 +45 @@
 /*
   Open up the brlock database. Close it down using talloc_free(). We
-  need the messaging_ctx to allow for pending lock notifications.
+  need the imessaging_ctx to allow for pending lock notifications.
 */
-struct brl_context *brl_init(TALLOC_CTX *mem_ctx, struct server_id server, 
+struct brl_context *brlock_init(TALLOC_CTX *mem_ctx, struct server_id server, 
                              struct loadparm_context *lp_ctx,
-                             struct messaging_context *messaging_ctx)
+                             struct imessaging_context *imessaging_ctx)
 {
         if (ops == NULL) {
                 brl_tdb_init_ops();
         }
-        return ops->brl_init(mem_ctx, server, lp_ctx, messaging_ctx);
+        return ops->brl_init(mem_ctx, server, lp_ctx, imessaging_ctx);
 }
 
-struct brl_handle *brl_create_handle(TALLOC_CTX *mem_ctx, struct ntvfs_handle *ntvfs, DATA_BLOB *file_key)
+struct brl_handle *brlock_create_handle(TALLOC_CTX *mem_ctx, struct ntvfs_handle *ntvfs, DATA_BLOB *file_key)
 {
         return ops->brl_create_handle(mem_ctx, ntvfs, file_key);
@@ -70 +69 @@
   notification is sent, identified by the notify_ptr
 */
-NTSTATUS brl_lock(struct brl_context *brl,
+NTSTATUS brlock_lock(struct brl_context *brl,
                   struct brl_handle *brlh,
                   uint32_t smbpid,
@@ -84 +83 @@
  Unlock a range of bytes.
 */
-NTSTATUS brl_unlock(struct brl_context *brl,
+NTSTATUS brlock_unlock(struct brl_context *brl,
                     struct brl_handle *brlh, 
                     uint32_t smbpid,
@@ -97 +96 @@
   getting it. In either case they no longer need to be notified.
 */
-NTSTATUS brl_remove_pending(struct brl_context *brl,
+NTSTATUS brlock_remove_pending(struct brl_context *brl,
                             struct brl_handle *brlh, 
                             void *notify_ptr)
@@ -108 +107 @@
   Test if we are allowed to perform IO on a region of an open file
 */
-NTSTATUS brl_locktest(struct brl_context *brl,
+NTSTATUS brlock_locktest(struct brl_context *brl,
                       struct brl_handle *brlh,
                       uint32_t smbpid, 
@@ -121 +120 @@
  Remove any locks associated with a open file.
 */
-NTSTATUS brl_close(struct brl_context *brl,
+NTSTATUS brlock_close(struct brl_context *brl,
                    struct brl_handle *brlh)
 {
@@ -130 +129 @@
  Get a number of locks associated with a open file.
 */
-NTSTATUS brl_count(struct brl_context *brl,
+NTSTATUS brlock_count(struct brl_context *brl,
                    struct brl_handle *brlh,
                    int *count)

vendor/current/source4/ntvfs/common/brlock.h

@@ -25 +25 @@
         struct brl_context *(*brl_init)(TALLOC_CTX *, struct server_id , 
                                         struct loadparm_context *lp_ctx,
-                                        struct messaging_context *);
+                                        struct imessaging_context *);
         struct brl_handle *(*brl_create_handle)(TALLOC_CTX *, struct ntvfs_handle *, DATA_BLOB *);
         NTSTATUS (*brl_lock)(struct brl_context *,
@@ -52 +52 @@
 };
 
-
-void brl_set_ops(const struct brlock_ops *new_ops);
+void brlock_set_ops(const struct brlock_ops *new_ops);
 void brl_tdb_init_ops(void);
-void brl_ctdb_init_ops(void);
-

vendor/current/source4/ntvfs/common/brlock_tdb.c

@@ -27 +27 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
 #include "libcli/libcli.h"
@@ -36 +34 @@
 #include "ntvfs/ntvfs.h"
 #include "param/param.h"
+#include "dbwrap/dbwrap.h"
 
 /*
@@ -47 +46 @@
 /* this struct is typicaly attached to tcon */
 struct brl_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct server_id server;
-        struct messaging_context *messaging_ctx;
+        struct imessaging_context *imessaging_ctx;
 };
 
@@ -90 +89 @@
 /*
   Open up the brlock.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for
+  talloc_free(). We need the imessaging_ctx to allow for
   pending lock notifications.
 */
 static struct brl_context *brl_tdb_init(TALLOC_CTX *mem_ctx, struct server_id server, 
                                         struct loadparm_context *lp_ctx,
-                                    struct messaging_context *messaging_ctx)
+                                    struct imessaging_context *imessaging_ctx)
 {
         struct brl_context *brl;
@@ -104 +103 @@
         }
 
-        brl->w = cluster_tdb_tmp_open(brl, lp_ctx, "brlock.tdb", TDB_DEFAULT);
-        if (brl->w == NULL) {
+        brl->db = cluster_db_tmp_open(brl, lp_ctx, "brlock", TDB_DEFAULT);
+        if (brl->db == NULL) {
                 talloc_free(brl);
                 return NULL;
@@ -111 +110 @@
 
         brl->server = server;
-        brl->messaging_ctx = messaging_ctx;
+        brl->imessaging_ctx = imessaging_ctx;
 
         return brl;
@@ -152 +151 @@
                             struct lock_struct *lck2)
 {
-        /* this extra check is not redundent - it copes with locks
+        /* this extra check is not redundant - it copes with locks
            that go beyond the end of 64 bit file space */
         if (lck1->size != 0 &&
@@ -243 +242 @@
 
         /* in SMB2 mode always return NT_STATUS_LOCK_NOT_GRANTED! */
-        if (lock->ntvfs->ctx->protocol == PROTOCOL_SMB2) {
+        if (lock->ntvfs->ctx->protocol >= PROTOCOL_SMB2_02) {
                 return NT_STATUS_LOCK_NOT_GRANTED;
         }
@@ -303 +302 @@
         struct lock_struct lock, *locks=NULL;
         NTSTATUS status;
+        struct db_record *locked;
 
         kbuf.dptr = brlh->key.data;
@@ -311 +311 @@
         }
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
@@ -329 +330 @@
 
                 if (NT_STATUS_IS_OK(status)) {
-                        tdb_chainunlock(brl->w->tdb, kbuf);
+                        talloc_free(locked);
                         return NT_STATUS_OK;
                 }
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
 
         lock.context.smbpid = smbpid;
@@ -359 +360 @@
 
         /* no conflicts - add it to the list of locks */
-        locks = realloc_p(locks, struct lock_struct, count+1);
+        /* FIXME: a dbwrap_record_append() would help here! */
+        locks = talloc_array(locked, struct lock_struct, count+1);
         if (!locks) {
                 status = NT_STATUS_NO_MEMORY;
                 goto fail;
-        } else {
-                dbuf.dptr = (uint8_t *)locks;
-        }
+        }
+        memcpy(locks, dbuf.dptr, dbuf.dsize);
         locks[count] = lock;
+
+        dbuf.dptr = (unsigned char *)locks;
         dbuf.dsize += sizeof(lock);
 
-        if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+        status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto fail;
         }
 
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
 
         /* the caller needs to know if the real lock was granted. If
@@ -387 +389 @@
 
  fail:
-
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -420 +420 @@
                                 last_notice = i;
                         }
-                        messaging_send_ptr(brl->messaging_ctx, locks[i].context.server, 
+                        imessaging_send_ptr(brl->imessaging_ctx, locks[i].context.server,
                                            MSG_BRL_RETRY, locks[i].notify_ptr);
                 }
@@ -456 +456 @@
         struct lock_struct *locks, *lock;
         struct lock_context context;
+        struct db_record *locked;
         NTSTATUS status;
 
@@ -465 +466 @@
         }
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
-                return NT_STATUS_RANGE_NOT_LOCKED;
-        }
+        dbuf = dbwrap_record_get_value(locked);
 
         context.smbpid = smbpid;
@@ -510 +507 @@
                 /* found it - delete it */
                 if (count == 1) {
-                        if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                        status = dbwrap_record_delete(locked);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto fail;
                         }
@@ -526 +523 @@
                         
                         dbuf.dsize = count * sizeof(*locks);
-                        
-                        if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+
+                        status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto fail;
                         }
                 }
-                
-                free(dbuf.dptr);
-                tdb_chainunlock(brl->w->tdb, kbuf);
+
+                talloc_free(locked);
                 return NT_STATUS_OK;
         }
@@ -542 +538 @@
 
  fail:
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -561 +556 @@
         struct lock_struct *locks;
         NTSTATUS status;
+        struct db_record *locked;
 
         kbuf.dptr = brlh->key.data;
         kbuf.dsize = brlh->key.length;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
         if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+                talloc_free(locked);
                 return NT_STATUS_RANGE_NOT_LOCKED;
         }
@@ -587 +584 @@
                         /* found it - delete it */
                         if (count == 1) {
-                                if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                                status = dbwrap_record_delete(locked);
+                                if (!NT_STATUS_IS_OK(status)) {
                                         goto fail;
                                 }
@@ -598 +595 @@
                                 count--;
                                 dbuf.dsize = count * sizeof(*locks);
-                                if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                                status = dbwrap_record_store(locked, dbuf,
+                                                             TDB_REPLACE);
+                                if (!NT_STATUS_IS_OK(status)) {
                                         goto fail;
                                 }
                         }
                         
-                        free(dbuf.dptr);
-                        tdb_chainunlock(brl->w->tdb, kbuf);
+                        talloc_free(locked);
                         return NT_STATUS_OK;
                 }
@@ -614 +611 @@
 
  fail:
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -632 +628 @@
         int count, i;
         struct lock_struct lock, *locks;
+        NTSTATUS status;
 
         kbuf.dptr = brlh->key.data;
@@ -640 +637 @@
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch(brl->db, brl, kbuf, &dbuf);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
                 return NT_STATUS_OK;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return status;
         }
 
@@ -659 +658 @@
         for (i=0; i<count; i++) {
                 if (brl_tdb_conflict_other(&locks[i], &lock)) {
-                        free(dbuf.dptr);
+                        talloc_free(dbuf.dptr);
                         return NT_STATUS_FILE_LOCK_CONFLICT;
                 }
         }
 
-        free(dbuf.dptr);
+        talloc_free(dbuf.dptr);
         return NT_STATUS_OK;
 }
@@ -678 +677 @@
         int count, i, dcount=0;
         struct lock_struct *locks;
+        struct db_record *locked;
         NTSTATUS status;
 
@@ -683 +683 @@
         kbuf.dsize = brlh->key.length;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
         if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+                talloc_free(locked);
                 return NT_STATUS_OK;
         }
@@ -717 +717 @@
 
         if (count == 0) {
-                if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
+                status = dbwrap_record_delete(locked);
         } else if (dcount != 0) {
                 /* tell all pending lock holders for this file that
@@ -728 +726 @@
                 dbuf.dsize = count * sizeof(*locks);
 
-                if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-        }
-
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+                status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+        }
+        talloc_free(locked);
 
         return status;
@@ -743 +737 @@
 {
         TDB_DATA kbuf, dbuf;
+        NTSTATUS status;
 
         kbuf.dptr = brlh->key.data;
@@ -748 +743 @@
         *count = 0;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+        status = dbwrap_fetch(brl->db, brl, kbuf, &dbuf);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
                 return NT_STATUS_OK;
-        }
-
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         *count = dbuf.dsize / sizeof(struct lock_struct);
 
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(dbuf.dptr);
 
         return NT_STATUS_OK;
@@ -780 +770 @@
 void brl_tdb_init_ops(void)
 {
-        brl_set_ops(&brlock_tdb_ops);
-}
+        brlock_set_ops(&brlock_tdb_ops);
+}

vendor/current/source4/ntvfs/common/init.c

@@ -27 +27 @@
 #include "ntvfs/sysdep/sys_notify.h"
 
+NTSTATUS ntvfs_common_init(void);
+
 NTSTATUS ntvfs_common_init(void)
 {

vendor/current/source4/ntvfs/common/notify.c

@@ -26 +26 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
-#include "../lib/util/util_tdb.h"
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
-#include "librpc/gen_ndr/ndr_s4_notify.h"
+#include "librpc/gen_ndr/ndr_notify.h"
 #include "../lib/util/dlinklist.h"
 #include "ntvfs/common/ntvfs_common.h"
@@ -38 +35 @@
 #include "param/param.h"
 #include "lib/util/tsort.h"
+#include "lib/dbwrap/dbwrap.h"
+#include "../lib/util/util_tdb.h"
 
 struct notify_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct server_id server;
-        struct messaging_context *messaging_ctx;
+        struct imessaging_context *imessaging_ctx;
         struct notify_list *list;
         struct notify_array *array;
-        int seqnum;
+        int64_t seqnum;
         struct sys_notify_context *sys_notify_ctx;
 };
@@ -64 +63 @@
 
 static NTSTATUS notify_remove_all(struct notify_context *notify);
-static void notify_handler(struct messaging_context *msg_ctx, void *private_data, 
+static void notify_handler(struct imessaging_context *msg_ctx, void *private_data,
                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data);
 
@@ -72 +71 @@
 static int notify_destructor(struct notify_context *notify)
 {
-        messaging_deregister(notify->messaging_ctx, MSG_PVFS_NOTIFY, notify);
+        imessaging_deregister(notify->imessaging_ctx, MSG_PVFS_NOTIFY, notify);
         notify_remove_all(notify);
         return 0;
@@ -79 +78 @@
 /*
   Open up the notify.tdb database. You should close it down using
-  talloc_free(). We need the messaging_ctx to allow for notifications
+  talloc_free(). We need the imessaging_ctx to allow for notifications
   via internal messages
 */
 struct notify_context *notify_init(TALLOC_CTX *mem_ctx, struct server_id server, 
-                                   struct messaging_context *messaging_ctx,
+                                   struct imessaging_context *imessaging_ctx,
                                    struct loadparm_context *lp_ctx,
                                    struct tevent_context *ev,
@@ -103 +102 @@
         }
 
-        notify->w = cluster_tdb_tmp_open(notify, lp_ctx, "notify.tdb", TDB_SEQNUM);
-        if (notify->w == NULL) {
+        notify->db = cluster_db_tmp_open(notify, lp_ctx, "notify", TDB_SEQNUM);
+        if (notify->db == NULL) {
                 talloc_free(notify);
                 return NULL;
@@ -110 +109 @@
 
         notify->server = server;
-        notify->messaging_ctx = messaging_ctx;
+        notify->imessaging_ctx = imessaging_ctx;
         notify->list = NULL;
         notify->array = NULL;
-        notify->seqnum = tdb_get_seqnum(notify->w->tdb);
+        notify->seqnum = dbwrap_get_seqnum(notify->db);
 
         talloc_set_destructor(notify, notify_destructor);
@@ -119 +118 @@
         /* register with the messaging subsystem for the notify
            message type */
-        messaging_register(notify->messaging_ctx, notify, 
+        imessaging_register(notify->imessaging_ctx, notify,
                            MSG_PVFS_NOTIFY, notify_handler);
 
@@ -131 +130 @@
   lock the notify db
 */
-static NTSTATUS notify_lock(struct notify_context *notify)
-{
-        if (tdb_lock_bystring(notify->w->tdb, NOTIFY_KEY) != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-        return NT_STATUS_OK;
-}
-
-/*
-  unlock the notify db
-*/
-static void notify_unlock(struct notify_context *notify)
-{
-        tdb_unlock_bystring(notify->w->tdb, NOTIFY_KEY);
+static struct db_record *notify_lock(struct notify_context *notify)
+{
+        TDB_DATA key = string_term_tdb_data(NOTIFY_KEY);
+
+        return dbwrap_fetch_locked(notify->db, notify, key);
+}
+
+static void notify_unlock(struct db_record *lock)
+{
+        talloc_free(lock);
 }
 
@@ -156 +151 @@
         enum ndr_err_code ndr_err;
         int seqnum;
-
-        seqnum = tdb_get_seqnum(notify->w->tdb);
+        NTSTATUS status;
+
+        seqnum = dbwrap_get_seqnum(notify->db);
 
         if (seqnum == notify->seqnum && notify->array != NULL) {
@@ -169 +165 @@
         NT_STATUS_HAVE_NO_MEMORY(notify->array);
 
-        dbuf = tdb_fetch_bystring(notify->w->tdb, NOTIFY_KEY);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch_bystring(notify->db, notify, NOTIFY_KEY, &dbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 return NT_STATUS_OK;
         }
@@ -179 +175 @@
         ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->array,
                                        (ndr_pull_flags_fn_t)ndr_pull_notify_array);
-        free(dbuf.dptr);
+        talloc_free(dbuf.dptr);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return ndr_map_error2ntstatus(ndr_err);
@@ -204 +200 @@
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
-        int ret;
         TALLOC_CTX *tmp_ctx;
+        NTSTATUS status;
 
         /* if possible, remove some depth arrays */
@@ -215 +211 @@
         /* we might just be able to delete the record */
         if (notify->array->num_depths == 0) {
-                ret = tdb_delete_bystring(notify->w->tdb, NOTIFY_KEY);
-                if (ret != 0) {
-                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-                return NT_STATUS_OK;
+                return dbwrap_delete_bystring(notify->db, NOTIFY_KEY);
         }
 
@@ -234 +226 @@
         dbuf.dptr = blob.data;
         dbuf.dsize = blob.length;
-                
-        ret = tdb_store_bystring(notify->w->tdb, NOTIFY_KEY, dbuf, TDB_REPLACE);
+
+        status = dbwrap_store_bystring(notify->db, NOTIFY_KEY, dbuf,
+                                       TDB_REPLACE);
         talloc_free(tmp_ctx);
-        if (ret != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        return NT_STATUS_OK;
+        return status;
 }
 
@@ -248 +237 @@
   handle incoming notify messages
 */
-static void notify_handler(struct messaging_context *msg_ctx, void *private_data, 
+static void notify_handler(struct imessaging_context *msg_ctx, void *private_data,
                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
 {
@@ -355 +344 @@
         size_t len;
         int depth;
+        struct db_record *locked;
 
         /* see if change notify is enabled at all */
@@ -361 +351 @@
         }
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
@@ -416 +408 @@
 
 done:
-        notify_unlock(notify);
+        notify_unlock(locked);
         talloc_free(tmp_path);
 
@@ -431 +423 @@
         int i, depth;
         struct notify_depth *d;
+        struct db_record *locked;
 
         /* see if change notify is enabled at all */
@@ -451 +444 @@
         talloc_free(listel);
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
         if (!NT_STATUS_IS_OK(status)) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return status;
         }
 
         if (depth >= notify->array->num_depths) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -475 +470 @@
         }
         if (i == d->num_entries) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -487 +482 @@
         status = notify_save(notify);
 
-        notify_unlock(notify);
+        notify_unlock(locked);
 
         return status;
@@ -499 +494 @@
         NTSTATUS status;
         int i, depth, del_count=0;
+        struct db_record *locked;
 
         if (notify->list == NULL) {
@@ -504 +500 @@
         }
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
         if (!NT_STATUS_IS_OK(status)) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return status;
         }
@@ -534 +532 @@
         }
 
-        notify_unlock(notify);
+        notify_unlock(locked);
 
         return status;
@@ -553 +551 @@
 
         ev.action = action;
+        ev.dir = discard_const_p(char, "");
         ev.path = path;
         ev.private_data = e->private_data;
@@ -564 +563 @@
         }
 
-        status = messaging_send(notify->messaging_ctx, e->server, 
+        status = imessaging_send(notify->imessaging_ctx, e->server,
                                 MSG_PVFS_NOTIFY, &data);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(tmp_ctx);
+                return;
+        }
+
         talloc_free(tmp_ctx);
 }

vendor/current/source4/ntvfs/common/opendb.c

@@ -56 +56 @@
 /*
   Open up the openfiles.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for pending open
+  talloc_free(). We need the imessaging_ctx to allow for pending open
   notifications.
 */

vendor/current/source4/ntvfs/common/opendb.h

@@ -58 +58 @@
 void odb_set_ops(const struct opendb_ops *new_ops);
 void odb_tdb_init_ops(void);
-void odb_ctdb_init_ops(void);

vendor/current/source4/ntvfs/common/opendb_tdb.c

@@ -41 +41 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
+#include "lib/dbwrap/dbwrap.h"
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
 #include "librpc/gen_ndr/ndr_opendb.h"
@@ -53 +52 @@
 
 struct odb_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct ntvfs_context *ntvfs_ctx;
         bool oplocks;
@@ -65 +64 @@
 struct odb_lock {
         struct odb_context *odb;
-        TDB_DATA key;
+        struct db_record *locked;
 
         struct opendb_file file;
@@ -75 +74 @@
 };
 
-static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
+static NTSTATUS odb_oplock_break_send(struct imessaging_context *msg_ctx,
                                       struct opendb_entry *e,
                                       uint8_t level);
@@ -81 +80 @@
 /*
   Open up the openfiles.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for pending open
+  talloc_free(). We need the imessaging_ctx to allow for pending open
   notifications.
 */
@@ -94 +93 @@
         }
 
-        odb->w = cluster_tdb_tmp_open(odb, ntvfs_ctx->lp_ctx, "openfiles.tdb", TDB_DEFAULT);
-        if (odb->w == NULL) {
+        odb->db = cluster_db_tmp_open(odb, ntvfs_ctx->lp_ctx,
+                                      "openfiles", TDB_DEFAULT);
+        if (odb->db == NULL) {
                 talloc_free(odb);
                 return NULL;
@@ -112 +112 @@
 }
 
-/*
-  destroy a lock on the database
-*/
-static int odb_lock_destructor(struct odb_lock *lck)
-{
-        tdb_chainunlock(lck->odb->w->tdb, lck->key);
-        return 0;
-}
-
 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file);
 
@@ -132 +123 @@
         struct odb_lock *lck;
         NTSTATUS status;
+        TDB_DATA key;
 
         lck = talloc(mem_ctx, struct odb_lock);
@@ -139 +131 @@
 
         lck->odb = talloc_reference(lck, odb);
-        lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
-        lck->key.dsize = file_key->length;
-        if (lck->key.dptr == NULL) {
+        key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
+        key.dsize = file_key->length;
+        if (key.dptr == NULL) {
                 talloc_free(lck);
                 return NULL;
         }
 
-        if (tdb_chainlock(odb->w->tdb, lck->key) != 0) {
+        lck->locked = dbwrap_fetch_locked(odb->db, lck, key);
+        if (!lck->locked) {
                 talloc_free(lck);
                 return NULL;
@@ -152 +145 @@
 
         ZERO_STRUCT(lck->can_open);
-
-        talloc_set_destructor(lck, odb_lock_destructor);
 
         status = odb_pull_record(lck, &lck->file);
@@ -169 +160 @@
 static DATA_BLOB odb_tdb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
 {
-        return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
+        TDB_DATA key = dbwrap_record_get_key(lck->locked);
+        return data_blob_talloc(mem_ctx, key.dptr, key.dsize);
 }
 
@@ -234 +226 @@
 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
 {
-        struct odb_context *odb = lck->odb;
         TDB_DATA dbuf;
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
 
-        dbuf = tdb_fetch(odb->w->tdb, lck->key);
-        if (dbuf.dptr == NULL) {
+        dbuf = dbwrap_record_get_value(lck->locked);
+        if (!dbuf.dptr) {
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -248 +239 @@
 
         ndr_err = ndr_pull_struct_blob(&blob, lck, file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
-        free(dbuf.dptr);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return ndr_map_error2ntstatus(ndr_err);
@@ -261 +251 @@
 static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
 {
-        struct odb_context *odb = lck->odb;
         TDB_DATA dbuf;
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
-        int ret;
+        NTSTATUS status;
 
         if (file->num_entries == 0) {
-                ret = tdb_delete(odb->w->tdb, lck->key);
-                if (ret != 0) {
-                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-                return NT_STATUS_OK;
+                return dbwrap_record_delete(lck->locked);
         }
 
@@ -283 +268 @@
         dbuf.dsize = blob.length;
                 
-        ret = tdb_store(odb->w->tdb, lck->key, dbuf, TDB_REPLACE);
+        status = dbwrap_record_store(lck->locked, dbuf, TDB_REPLACE);
         data_blob_free(&blob);
-        if (ret != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        return NT_STATUS_OK;
+        return status;
 }
 
@@ -295 +276 @@
   send an oplock break to a client
 */
-static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
+static NTSTATUS odb_oplock_break_send(struct imessaging_context *msg_ctx,
                                       struct opendb_entry *e,
                                       uint8_t level)
@@ -312 +293 @@
         blob = data_blob_const(&op_break, sizeof(op_break));
 
-        status = messaging_send(msg_ctx, e->server,
+        status = imessaging_send(msg_ctx, e->server,
                                 MSG_NTVFS_OPLOCK_BREAK, &blob);
         NT_STATUS_NOT_OK_RETURN(status);
@@ -612 +593 @@
         /* send any pending notifications, removing them once sent */
         for (i=0;i<lck->file.num_pending;i++) {
-                messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
+                imessaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
                                    lck->file.pending[i].server,
                                    MSG_PVFS_RETRY_OPEN,
@@ -667 +648 @@
         /* send any pending notifications, removing them once sent */
         for (i=0;i<lck->file.num_pending;i++) {
-                messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
+                imessaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
                                    lck->file.pending[i].server,
                                    MSG_PVFS_RETRY_OPEN,

vendor/current/source4/ntvfs/common/wscript_build

@@ -4 +4 @@
         source='init.c brlock.c brlock_tdb.c opendb.c opendb_tdb.c notify.c',
         autoproto='proto.h',
+        deps='util_tdb tdb-wrap',
         public_deps='NDR_OPENDB NDR_NOTIFY sys_notify sys_lease share'
         )

vendor/current/source4/ntvfs/ipc/ipc_rap.c

@@ -256 +256 @@
         struct rap_NetShareEnum r;
         NTSTATUS result;
+        uint32_t offset_save = 0;
+        struct rap_heap_save heap_save = {0};
 
         RAP_GOTO(rap_srv_pull_word(call, &r.in.level));
@@ -283 +285 @@
 
                 int i = r.out.count;
-                uint32_t offset_save;
-                struct rap_heap_save heap_save;
 
                 offset_save = call->ndr_push_data->offset;
@@ -336 +336 @@
         struct rap_NetServerEnum2 r;
         NTSTATUS result;
+        uint32_t offset_save = 0;
+        struct rap_heap_save heap_save = {0};
 
         RAP_GOTO(rap_srv_pull_word(call, &r.in.level));
@@ -365 +367 @@
 
                 int i = r.out.count;
-                uint32_t offset_save;
-                struct rap_heap_save heap_save;
 
                 offset_save = call->ndr_push_data->offset;

vendor/current/source4/ntvfs/ipc/rap_server.c

@@ -73 +73 @@
                 r->out.info[i].info1.reserved1 = 0;
                 r->out.info[i].info1.share_type = dcesrv_common_get_share_type(mem_ctx, NULL, scfg);
-                r->out.info[i].info1.comment = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
+                r->out.info[i].info1.comment = share_string_option(mem_ctx, scfg, SHARE_COMMENT, "");
                 talloc_free(scfg);
                 j++;

vendor/current/source4/ntvfs/ipc/vfs_ipc.c

@@ -30 +30 @@
 #include "../librpc/gen_ndr/rap.h"
 #include "ntvfs/ipc/proto.h"
-#include "libcli/raw/ioctl.h"
+#include "../libcli/smb/smb_constants.h"
 #include "param/param.h"
 #include "../lib/tsocket/tsocket.h"
@@ -39 +39 @@
 #include "auth/credentials/credentials.h"
 #include "auth/credentials/credentials_krb5.h"
-#include <gssapi/gssapi.h>
+#include "system/kerberos.h"
+#include "system/gssapi.h"
 #include "system/locale.h"
+#include "system/filesys.h"
 
 /* this is the private structure used to keep the state of an open
@@ -259 +261 @@
         case RAW_OPEN_NTTRANS_CREATE:
                 fname = oi->ntcreatex.in.fname;
+                while (fname[0] == '\\') fname++;
                 break;
         case RAW_OPEN_OPENX:
                 fname = oi->openx.in.fname;
+                while (fname[0] == '\\') fname++;
+                if (strncasecmp(fname, "PIPE\\", 5) != 0) {
+                        return NT_STATUS_OBJECT_PATH_SYNTAX_BAD;
+                }
+                while (fname[0] == '\\') fname++;
                 break;
         case RAW_OPEN_SMB2:
@@ -282 +290 @@
         p = talloc(h, struct pipe_state);
         NT_STATUS_HAVE_NO_MEMORY(p);
-
-        while (fname[0] == '\\') fname++;
 
         /* check for valid characters in name */
@@ -354 +360 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -603 +609 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -688 +694 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -732 +738 @@
         struct pipe_state *p;
 
-        if (io->generic.level != RAW_CLOSE_CLOSE) {
+        if (io->generic.level != RAW_CLOSE_GENERIC) {
                 return ntvfs_map_close(ntvfs, req, io);
         }
 
-        p = pipe_state_find(ipriv, io->close.in.file.ntvfs);
+        ZERO_STRUCT(io->generic.out);
+
+        p = pipe_state_find(ipriv, io->generic.in.file.ntvfs);
         if (!p) {
                 return NT_STATUS_INVALID_HANDLE;
@@ -1010 +1018 @@
                 goto reply;
         } else if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -1046 +1054 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -1174 +1182 @@
         io->smb2.out.unknown2   = 0;
         io->smb2.out.unknown3   = 0;
-        io->smb2.out.in         = io->smb2.in.out;
+        io->smb2.out.in         = data_blob_null;
         io->smb2.out.out = data_blob_talloc(req, NULL, io->smb2.in.max_response_size);
         NT_STATUS_HAVE_NO_MEMORY(io->smb2.out.out.data);
@@ -1216 +1224 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -1252 +1260 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 goto reply;
         }
@@ -1303 +1311 @@
 
         /* fill in all the operations */
-        ops.connect = ipc_connect;
-        ops.disconnect = ipc_disconnect;
-        ops.unlink = ipc_unlink;
-        ops.chkpath = ipc_chkpath;
-        ops.qpathinfo = ipc_qpathinfo;
-        ops.setpathinfo = ipc_setpathinfo;
-        ops.open = ipc_open;
-        ops.mkdir = ipc_mkdir;
-        ops.rmdir = ipc_rmdir;
-        ops.rename = ipc_rename;
-        ops.copy = ipc_copy;
-        ops.ioctl = ipc_ioctl;
-        ops.read = ipc_read;
-        ops.write = ipc_write;
-        ops.seek = ipc_seek;
-        ops.flush = ipc_flush;  
-        ops.close = ipc_close;
-        ops.exit = ipc_exit;
-        ops.lock = ipc_lock;
-        ops.setfileinfo = ipc_setfileinfo;
-        ops.qfileinfo = ipc_qfileinfo;
-        ops.fsinfo = ipc_fsinfo;
-        ops.lpq = ipc_lpq;
-        ops.search_first = ipc_search_first;
-        ops.search_next = ipc_search_next;
-        ops.search_close = ipc_search_close;
-        ops.trans = ipc_trans;
-        ops.logoff = ipc_logoff;
-        ops.async_setup = ipc_async_setup;
-        ops.cancel = ipc_cancel;
+        ops.connect_fn = ipc_connect;
+        ops.disconnect_fn = ipc_disconnect;
+        ops.unlink_fn = ipc_unlink;
+        ops.chkpath_fn = ipc_chkpath;
+        ops.qpathinfo_fn = ipc_qpathinfo;
+        ops.setpathinfo_fn = ipc_setpathinfo;
+        ops.open_fn = ipc_open;
+        ops.mkdir_fn = ipc_mkdir;
+        ops.rmdir_fn = ipc_rmdir;
+        ops.rename_fn = ipc_rename;
+        ops.copy_fn = ipc_copy;
+        ops.ioctl_fn = ipc_ioctl;
+        ops.read_fn = ipc_read;
+        ops.write_fn = ipc_write;
+        ops.seek_fn = ipc_seek;
+        ops.flush_fn = ipc_flush;
+        ops.close_fn = ipc_close;
+        ops.exit_fn = ipc_exit;
+        ops.lock_fn = ipc_lock;
+        ops.setfileinfo_fn = ipc_setfileinfo;
+        ops.qfileinfo_fn = ipc_qfileinfo;
+        ops.fsinfo_fn = ipc_fsinfo;
+        ops.lpq_fn = ipc_lpq;
+        ops.search_first_fn = ipc_search_first;
+        ops.search_next_fn = ipc_search_next;
+        ops.search_close_fn = ipc_search_close;
+        ops.trans_fn = ipc_trans;
+        ops.logoff_fn = ipc_logoff;
+        ops.async_setup_fn = ipc_async_setup;
+        ops.cancel_fn = ipc_cancel;
 
         /* register ourselves with the NTVFS subsystem. */

vendor/current/source4/ntvfs/nbench/vfs_nbench.c

@@ -28 +28 @@
 #include "system/filesys.h"
 
+NTSTATUS ntvfs_nbench_init(void);
+
 /* this is stored in ntvfs_private */
 struct nbench_private {
@@ -125 +127 @@
 
         logname = talloc_asprintf(req, "/tmp/nbenchlog%d.%u", ntvfs->depth,
-                                  getpid());
+                                  (unsigned int)getpid());
         NT_STATUS_HAVE_NO_MEMORY(logname);
         nprivates->log_fd = open(logname, O_WRONLY|O_CREAT|O_APPEND, 0644);
@@ -164 +166 @@
 {
         union smb_unlink *unl = req->async_states->private_data;
-
         nbench_log(req, "Unlink \"%s\" 0x%x %s\n", 
                    unl->unlink.in.pattern, unl->unlink.in.attrib, 
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -212 +213 @@
         nbench_log(req, "Chkpath \"%s\" %s\n", 
                    cp->chkpath.in.path, 
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -238 +239 @@
                    info->generic.in.file.path, 
                    info->generic.level,
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -263 +264 @@
                    nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
                    info->generic.level,
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -288 +289 @@
                    st->generic.in.file.path, 
                    st->generic.level,
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -320 +321 @@
                            io->ntcreatex.in.open_disposition, 
                            nbench_ntvfs_handle_string(req, io->ntcreatex.out.file.ntvfs),
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
 
@@ -372 +373 @@
         nbench_log(req, "Rmdir \"%s\" %s\n", 
                    rd->in.path, 
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -399 +400 @@
                            ren->rename.in.pattern1, 
                            ren->rename.in.pattern2, 
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
 
@@ -458 +459 @@
                            rd->readx.in.maxcnt,
                            rd->readx.out.nread,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
         default:
@@ -496 +497 @@
                            wr->writex.in.count,
                            wr->writex.out.nwritten,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
 
@@ -508 +509 @@
                            wr->write.in.count,
                            wr->write.out.nwritten,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
 
@@ -562 +563 @@
                 nbench_log(req, "Flush %s %s\n",
                            nbench_ntvfs_handle_string(req, io->flush.in.file.ntvfs),
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
         case RAW_FLUSH_ALL:
                 nbench_log(req, "Flush %d %s\n",
                            0xFFFF,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
         default:
@@ -600 +601 @@
                 nbench_log(req, "Close %s %s\n",
                            nbench_ntvfs_handle_string(req, io->close.in.file.ntvfs),
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
 
@@ -717 +718 @@
                            (int)lck->lockx.in.locks[0].offset,
                            (int)lck->lockx.in.locks[0].count,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
         } else if (lck->generic.level == RAW_LOCK_LOCKX &&
                    lck->lockx.in.ulock_cnt == 1) {
@@ -724 +725 @@
                            (int)lck->lockx.in.locks[0].offset,
                            (int)lck->lockx.in.locks[0].count,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
         } else {
                 nbench_log(req, "Lock-%d - NOT HANDLED\n", lck->generic.level);
@@ -752 +753 @@
                    nbench_ntvfs_handle_string(req, info->generic.in.file.ntvfs),
                    info->generic.level,
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -777 +778 @@
         nbench_log(req, "QUERY_FS_INFORMATION %d %s\n", 
                    fs->generic.level, 
-                   get_nt_error_c_code(req->async_states->status));
+                   get_nt_error_c_code(req, req->async_states->status));
 
         PASS_THRU_REP_POST(req);
@@ -831 +832 @@
                            io->t2ffirst.in.max_count,
                            io->t2ffirst.out.count,
-                           get_nt_error_c_code(req->async_states->status));
+                           get_nt_error_c_code(req, req->async_states->status));
                 break;
                 
@@ -930 +931 @@
         
         /* fill in all the operations */
-        ops.connect = nbench_connect;
-        ops.disconnect = nbench_disconnect;
-        ops.unlink = nbench_unlink;
-        ops.chkpath = nbench_chkpath;
-        ops.qpathinfo = nbench_qpathinfo;
-        ops.setpathinfo = nbench_setpathinfo;
-        ops.open = nbench_open;
-        ops.mkdir = nbench_mkdir;
-        ops.rmdir = nbench_rmdir;
-        ops.rename = nbench_rename;
-        ops.copy = nbench_copy;
-        ops.ioctl = nbench_ioctl;
-        ops.read = nbench_read;
-        ops.write = nbench_write;
-        ops.seek = nbench_seek;
-        ops.flush = nbench_flush;       
-        ops.close = nbench_close;
-        ops.exit = nbench_exit;
-        ops.lock = nbench_lock;
-        ops.setfileinfo = nbench_setfileinfo;
-        ops.qfileinfo = nbench_qfileinfo;
-        ops.fsinfo = nbench_fsinfo;
-        ops.lpq = nbench_lpq;
-        ops.search_first = nbench_search_first;
-        ops.search_next = nbench_search_next;
-        ops.search_close = nbench_search_close;
-        ops.trans = nbench_trans;
-        ops.logoff = nbench_logoff;
-        ops.async_setup = nbench_async_setup;
-        ops.cancel = nbench_cancel;
+        ops.connect_fn = nbench_connect;
+        ops.disconnect_fn = nbench_disconnect;
+        ops.unlink_fn = nbench_unlink;
+        ops.chkpath_fn = nbench_chkpath;
+        ops.qpathinfo_fn = nbench_qpathinfo;
+        ops.setpathinfo_fn = nbench_setpathinfo;
+        ops.open_fn = nbench_open;
+        ops.mkdir_fn = nbench_mkdir;
+        ops.rmdir_fn = nbench_rmdir;
+        ops.rename_fn = nbench_rename;
+        ops.copy_fn = nbench_copy;
+        ops.ioctl_fn = nbench_ioctl;
+        ops.read_fn = nbench_read;
+        ops.write_fn = nbench_write;
+        ops.seek_fn = nbench_seek;
+        ops.flush_fn = nbench_flush;
+        ops.close_fn = nbench_close;
+        ops.exit_fn = nbench_exit;
+        ops.lock_fn = nbench_lock;
+        ops.setfileinfo_fn = nbench_setfileinfo;
+        ops.qfileinfo_fn = nbench_qfileinfo;
+        ops.fsinfo_fn = nbench_fsinfo;
+        ops.lpq_fn = nbench_lpq;
+        ops.search_first_fn = nbench_search_first;
+        ops.search_next_fn = nbench_search_next;
+        ops.search_close_fn = nbench_search_close;
+        ops.trans_fn = nbench_trans;
+        ops.logoff_fn = nbench_logoff;
+        ops.async_setup_fn = nbench_async_setup;
+        ops.cancel_fn = nbench_cancel;
 
         /* we don't register a trans2 handler as we want to be able to
            log individual trans2 requests */
-        ops.trans2 = NULL;
+        ops.trans2_fn = NULL;
 
         /* register ourselves with the NTVFS subsystem. */

vendor/current/source4/ntvfs/ntvfs.h

@@ -25 +25 @@
 #include "param/share.h"
 #include "librpc/gen_ndr/security.h"
-#include "librpc/gen_ndr/server_id4.h"
+#include "librpc/gen_ndr/server_id.h"
 
 /* modules can use the following to determine if the interface has changed */
@@ -48 +48 @@
 
         /* initial setup */
-        NTSTATUS (*connect)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*connect_fn)(struct ntvfs_module_context *ntvfs,
                             struct ntvfs_request *req,
                             union smb_tcon *tcon);
-        NTSTATUS (*disconnect)(struct ntvfs_module_context *ntvfs);
+        NTSTATUS (*disconnect_fn)(struct ntvfs_module_context *ntvfs);
 
         /* async_setup - called when a backend is processing a async request */
-        NTSTATUS (*async_setup)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*async_setup_fn)(struct ntvfs_module_context *ntvfs,
                                 struct ntvfs_request *req,
                                 void *private_data);
 
         /* filesystem operations */
-        NTSTATUS (*fsinfo)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*fsinfo_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req,
                            union smb_fsinfo *fs);
 
         /* path operations */
-        NTSTATUS (*unlink)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*unlink_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req,
                            union smb_unlink *unl);
-        NTSTATUS (*chkpath)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*chkpath_fn)(struct ntvfs_module_context *ntvfs,
                             struct ntvfs_request *req,
                             union smb_chkpath *cp);
-        NTSTATUS (*qpathinfo)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*qpathinfo_fn)(struct ntvfs_module_context *ntvfs,
                               struct ntvfs_request *req,
                               union smb_fileinfo *st);
-        NTSTATUS (*setpathinfo)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*setpathinfo_fn)(struct ntvfs_module_context *ntvfs,
                                 struct ntvfs_request *req,
                                 union smb_setfileinfo *st);
-        NTSTATUS (*mkdir)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*mkdir_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           union smb_mkdir *md);
-        NTSTATUS (*rmdir)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*rmdir_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           struct smb_rmdir *rd);
-        NTSTATUS (*rename)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*rename_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req,
                            union smb_rename *ren);
-        NTSTATUS (*copy)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*copy_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req,
                          struct smb_copy *cp);
-        NTSTATUS (*open)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*open_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req,
                          union smb_open *oi);
 
         /* directory search */
-        NTSTATUS (*search_first)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*search_first_fn)(struct ntvfs_module_context *ntvfs,
                                  struct ntvfs_request *req,
                                  union smb_search_first *io, void *private_data,
-                                 bool (*callback)(void *private_data, const union smb_search_data *file));
-        NTSTATUS (*search_next)(struct ntvfs_module_context *ntvfs,
+                                 bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+        NTSTATUS (*search_next_fn)(struct ntvfs_module_context *ntvfs,
                                 struct ntvfs_request *req,
                                 union smb_search_next *io, void *private_data,
-                                bool (*callback)(void *private_data, const union smb_search_data *file));
-        NTSTATUS (*search_close)(struct ntvfs_module_context *ntvfs,
+                                bool (*callback_fn)(void *private_data, const union smb_search_data *file));
+        NTSTATUS (*search_close_fn)(struct ntvfs_module_context *ntvfs,
                                  struct ntvfs_request *req,
                                  union smb_search_close *io);
 
         /* operations on open files */
-        NTSTATUS (*ioctl)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*ioctl_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           union smb_ioctl *io);
-        NTSTATUS (*read)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*read_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req,
                          union smb_read *io);
-        NTSTATUS (*write)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*write_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           union smb_write *io);
-        NTSTATUS (*seek)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*seek_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req,
                          union smb_seek *io);
-        NTSTATUS (*flush)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*flush_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           union smb_flush *flush);
-        NTSTATUS (*lock)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*lock_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req,
                          union smb_lock *lck);
-        NTSTATUS (*qfileinfo)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*qfileinfo_fn)(struct ntvfs_module_context *ntvfs,
                               struct ntvfs_request *req,
                               union smb_fileinfo *info);
-        NTSTATUS (*setfileinfo)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*setfileinfo_fn)(struct ntvfs_module_context *ntvfs,
                                 struct ntvfs_request *req,
                                 union smb_setfileinfo *info);
-        NTSTATUS (*close)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*close_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           union smb_close *io);
 
         /* trans interface - used by IPC backend for pipes and RAP calls */
-        NTSTATUS (*trans)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*trans_fn)(struct ntvfs_module_context *ntvfs,
                           struct ntvfs_request *req,
                           struct smb_trans2 *trans);
 
         /* trans2 interface - only used by CIFS backend to prover complete passthru for testing */
-        NTSTATUS (*trans2)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*trans2_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req,
                            struct smb_trans2 *trans2);
 
         /* change notify request */
-        NTSTATUS (*notify)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*notify_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req,
                            union smb_notify *info);
 
         /* cancel - cancels any pending async request */
-        NTSTATUS (*cancel)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*cancel_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req);
 
         /* printing specific operations */
-        NTSTATUS (*lpq)(struct ntvfs_module_context *ntvfs, 
+        NTSTATUS (*lpq_fn)(struct ntvfs_module_context *ntvfs,
                         struct ntvfs_request *req,
                         union smb_lpq *lpq);
 
         /* logoff - called when a vuid is closed */
-        NTSTATUS (*logoff)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*logoff_fn)(struct ntvfs_module_context *ntvfs,
                            struct ntvfs_request *req);
-        NTSTATUS (*exit)(struct ntvfs_module_context *ntvfs,
+        NTSTATUS (*exit_fn)(struct ntvfs_module_context *ntvfs,
                          struct ntvfs_request *req);
 };
@@ -202 +202 @@
         struct loadparm_context *lp_ctx;
         struct tevent_context *event_ctx;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
 
         struct {
@@ -331 +331 @@
     }
 
-struct messaging_context;
+struct imessaging_context;
 #include "librpc/gen_ndr/security.h"
-#include "librpc/gen_ndr/s4_notify.h"
+#include "librpc/gen_ndr/notify.h"
 #include "ntvfs/ntvfs_proto.h"
 

vendor/current/source4/ntvfs/ntvfs_base.c

@@ -27 +27 @@
 #include "ntvfs/ntvfs.h"
 #include "param/param.h"
+#include "lib/util/samba_modules.h"
 
 /* the list of currently registered NTVFS backends, note that there
@@ -154 +155 @@
                                enum protocol_types protocol,
                                uint64_t ntvfs_client_caps,
-                               struct tevent_context *ev, struct messaging_context *msg,
+                               struct tevent_context *ev, struct imessaging_context *msg,
                                struct loadparm_context *lp_ctx,
                                struct server_id server_id, struct ntvfs_context **_ctx)
@@ -190 +191 @@
                 }
                 ntvfs->depth = i;
-                DLIST_ADD_END(ctx->modules, ntvfs, struct ntvfs_module_context *);
+                DLIST_ADD_END(ctx->modules, ntvfs);
         }
 
@@ -236 +237 @@
         initialized = true;
         
-        shared_init = load_samba_modules(NULL, lp_ctx, "ntvfs");
+        shared_init = load_samba_modules(NULL, "ntvfs");
 
         run_init_functions(static_init);

vendor/current/source4/ntvfs/ntvfs_generic.c

@@ -256 +256 @@
                 sf->standard.in.write_time  = write_time;
                 sf->standard.in.access_time = 0;
-                status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+                status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
         }
 
@@ -265 +265 @@
                 sf->generic.in.file.ntvfs    = io2->generic.out.file.ntvfs;
                 sf->end_of_file_info.in.size = set_size;
-                status = ntvfs->ops->setfileinfo(ntvfs, req, sf);
+                status = ntvfs->ops->setfileinfo_fn(ntvfs, req, sf);
                 if (NT_STATUS_IS_OK(status)) {
                         io->openx.out.size = io->openx.in.size;
@@ -417 +417 @@
                 io2->generic.in.fname = io->openx.in.fname;
                 
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
                 
@@ -434 +434 @@
                 io2->generic.in.fname = io->openold.in.fname;
 
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
 
@@ -460 +460 @@
                 io2->generic.in.ea_list->eas     = io->t2open.in.eas;
 
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
 
@@ -473 +473 @@
                         NTCREATEX_SHARE_ACCESS_READ | 
                         NTCREATEX_SHARE_ACCESS_WRITE;
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
 
@@ -486 +486 @@
                         NTCREATEX_SHARE_ACCESS_READ | 
                         NTCREATEX_SHARE_ACCESS_WRITE;
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
 
@@ -502 +502 @@
                         NTCREATEX_SHARE_ACCESS_READ | 
                         NTCREATEX_SHARE_ACCESS_WRITE;
-                status = ntvfs->ops->open(ntvfs, req, io2);
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
         case RAW_OPEN_SMB2:
@@ -550 +550 @@
                 io2->generic.in.create_options &= ~NTCREATEX_OPTIONS_ASYNC_ALERT;
 
-                status = ntvfs->ops->open(ntvfs, req, io2);             
+                status = ntvfs->ops->open_fn(ntvfs, req, io2);
                 break;
 
@@ -577 +577 @@
         /* and convert it to the required level */
         switch (fs->generic.level) {
-        case RAW_QFS_GENERIC:
-                return NT_STATUS_INVALID_LEVEL;
-
         case RAW_QFS_DSKATTR: {
                 /* map from generic to DSKATTR */
@@ -667 +664 @@
                 ZERO_STRUCT(fs->objectid_information.out.unknown);
                 return NT_STATUS_OK;
-        }
-
+
+        case RAW_QFS_SECTOR_SIZE_INFORMATION:
+                fs->sector_size_info.out.logical_bytes_per_sector
+                                                = fs2->generic.out.block_size;
+                fs->sector_size_info.out.phys_bytes_per_sector_atomic
+                                                = fs2->generic.out.block_size;
+                fs->sector_size_info.out.phys_bytes_per_sector_perf
+                                                = fs2->generic.out.block_size;
+                fs->sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic
+                                                = fs2->generic.out.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;
+
+        case RAW_QFS_GENERIC:
+        case RAW_QFS_UNIX_INFO:
+                return NT_STATUS_INVALID_LEVEL;
+        }
 
         return NT_STATUS_INVALID_LEVEL;
@@ -701 +717 @@
         fs2->generic.level = RAW_QFS_GENERIC;
 
-        status = ntvfs->ops->fsinfo(ntvfs, req, fs2);
+        status = ntvfs->ops->fsinfo_fn(ntvfs, req, fs2);
         return ntvfs_map_async_finish(req, status);
 }
@@ -716 +732 @@
         /* and convert it to the required level using results in info2 */
         switch (info->generic.level) {
-                case RAW_FILEINFO_GENERIC:
-                return NT_STATUS_INVALID_LEVEL;
         case RAW_FILEINFO_GETATTR:
                 info->getattr.out.attrib = info2->generic.out.attrib & 0xff;
@@ -911 +925 @@
                         info2->generic.out.alignment_requirement;
                 return NT_STATUS_OK;
-#if 0   
         case RAW_FILEINFO_UNIX_BASIC:
+#if 1
+                return NT_STATUS_INVALID_LEVEL;
+#else
                 info->unix_basic_info.out.end_of_file = info2->generic.out.end_of_file;
                 info->unix_basic_info.out.num_bytes = info2->generic.out.size;
@@ -927 +943 @@
                 info->unix_basic_info.out.nlink = info2->generic.out.nlink;
                 return NT_STATUS_OK;
-                
+#endif
         case RAW_FILEINFO_UNIX_LINK:
+#if 1
+                return NT_STATUS_INVALID_LEVEL;
+#else
                 info->unix_link_info.out.link_dest = info2->generic.out.link_dest;
                 return NT_STATUS_OK;
 #endif
+        case RAW_FILEINFO_GENERIC:
+        case RAW_FILEINFO_SEC_DESC:
+        case RAW_FILEINFO_EA_LIST:
+        case RAW_FILEINFO_UNIX_INFO2:
+        case RAW_FILEINFO_SMB2_ALL_EAS:
+        case RAW_FILEINFO_SMB2_ALL_INFORMATION:
+                return NT_STATUS_INVALID_LEVEL;
         }
 
@@ -982 +1008 @@
         info2->generic.in.file.ntvfs= info->generic.in.file.ntvfs;
 
-        status = ntvfs->ops->qfileinfo(ntvfs, req, info2);
+        status = ntvfs->ops->qfileinfo_fn(ntvfs, req, info2);
         return ntvfs_map_async_finish(req, status);
 }
@@ -1031 +1057 @@
         info2->generic.in.file.path     = info->generic.in.file.path;
 
-        status = ntvfs->ops->qpathinfo(ntvfs, req, info2);
+        status = ntvfs->ops->qpathinfo_fn(ntvfs, req, info2);
         return ntvfs_map_async_finish(req, status);
 }
@@ -1175 +1201 @@
          */
 
-        return ntvfs->ops->lock(ntvfs, req, lck2);
+        return ntvfs->ops->lock_fn(ntvfs, req, lck2);
 }
 
@@ -1218 +1244 @@
                         state = req->async_states->state;
                         req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
-                        status = ntvfs->ops->lock(ntvfs, req, lck);
+                        status = ntvfs->ops->lock_fn(ntvfs, req, lck);
                         req->async_states->state = state;
                 }
@@ -1239 +1265 @@
                         state = req->async_states->state;
                         req->async_states->state &= ~NTVFS_ASYNC_STATE_MAY_ASYNC;
-                        status = ntvfs->ops->close(ntvfs, req, cl);
+                        status = ntvfs->ops->close_fn(ntvfs, req, cl);
                         req->async_states->state = state;
                 }
@@ -1296 +1322 @@
                 wr2->writex.in.count     = wr->write.in.count;
                 wr2->writex.in.data      = wr->write.in.data;
-                status = ntvfs->ops->write(ntvfs, req, wr2);
+                status = ntvfs->ops->write_fn(ntvfs, req, wr2);
                 break;
 
@@ -1306 +1332 @@
                 wr2->writex.in.count     = wr->writeunlock.in.count;
                 wr2->writex.in.data      = wr->writeunlock.in.data;
-                status = ntvfs->ops->write(ntvfs, req, wr2);
+                status = ntvfs->ops->write_fn(ntvfs, req, wr2);
                 break;
 
@@ -1316 +1342 @@
                 wr2->writex.in.count     = wr->writeclose.in.count;
                 wr2->writex.in.data      = wr->writeclose.in.data;
-                status = ntvfs->ops->write(ntvfs, req, wr2);
+                status = ntvfs->ops->write_fn(ntvfs, req, wr2);
                 break;
 
@@ -1326 +1352 @@
                 wr2->writex.in.count     = wr->splwrite.in.count;
                 wr2->writex.in.data      = wr->splwrite.in.data;
-                status = ntvfs->ops->write(ntvfs, req, wr2);
+                status = ntvfs->ops->write_fn(ntvfs, req, wr2);
                 break;
 
@@ -1336 +1362 @@
                 wr2->writex.in.count     = wr->smb2.in.data.length;
                 wr2->writex.in.data      = wr->smb2.in.data.data;
-                status = ntvfs->ops->write(ntvfs, req, wr2);
+                status = ntvfs->ops->write_fn(ntvfs, req, wr2);
         }
 
@@ -1412 +1438 @@
                 rd2->readx.in.remaining = rd->read.in.remaining;
                 rd2->readx.out.data     = rd->read.out.data;
-                status = ntvfs->ops->read(ntvfs, req, rd2);
+                status = ntvfs->ops->read_fn(ntvfs, req, rd2);
                 break;
 
@@ -1422 +1448 @@
                 rd2->readx.in.remaining = 0;
                 rd2->readx.out.data     = rd->readbraw.out.data;
-                status = ntvfs->ops->read(ntvfs, req, rd2);
+                status = ntvfs->ops->read_fn(ntvfs, req, rd2);
                 break;
 
@@ -1439 +1465 @@
                 lck->lock.in.count      = rd->lockread.in.count;
                 lck->lock.in.offset     = rd->lockread.in.offset;
-                status = ntvfs->ops->lock(ntvfs, req, lck);
+                status = ntvfs->ops->lock_fn(ntvfs, req, lck);
                 req->async_states->state = state;
 
@@ -1450 +1476 @@
 
                 if (NT_STATUS_IS_OK(status)) {
-                        status = ntvfs->ops->read(ntvfs, req, rd2);
+                        status = ntvfs->ops->read_fn(ntvfs, req, rd2);
                 }
                 break;
@@ -1461 +1487 @@
                 rd2->readx.in.remaining = 0;
                 rd2->readx.out.data     = rd->smb2.out.data.data;
-                status = ntvfs->ops->read(ntvfs, req, rd2);
+                status = ntvfs->ops->read_fn(ntvfs, req, rd2);
                 break;
         }
@@ -1545 +1571 @@
         NT_STATUS_NOT_OK_RETURN(status);
 
-        status = ntvfs->ops->close(ntvfs, req, cl2);
+        status = ntvfs->ops->close_fn(ntvfs, req, cl2);
 
         return ntvfs_map_async_finish(req, status);
@@ -1607 +1633 @@
                 nt2->nttrans.in.completion_filter       = nt->smb2.in.completion_filter;
                 nt2->nttrans.in.recursive               = nt->smb2.in.recursive;
-                status = ntvfs->ops->notify(ntvfs, req, nt2);
+                status = ntvfs->ops->notify_fn(ntvfs, req, nt2);
                 break;
         }

vendor/current/source4/ntvfs/ntvfs_interface.c

@@ -27 +27 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->connect) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->connect(ntvfs, req, tcon);
+        if (!ntvfs->ops->connect_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->connect_fn(ntvfs, req, tcon);
 }
 
@@ -40 +40 @@
         }
         ntvfs = ntvfs_ctx->modules;
-        if (!ntvfs->ops->disconnect) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->disconnect(ntvfs);
+        if (!ntvfs->ops->disconnect_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->disconnect_fn(ntvfs);
 }
 
@@ -51 +51 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->async_setup) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->async_setup(ntvfs, req, private_data);
+        if (!ntvfs->ops->async_setup_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->async_setup_fn(ntvfs, req, private_data);
 }
 
@@ -61 +61 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->fsinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->fsinfo(ntvfs, req, fs);
+        if (!ntvfs->ops->fsinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->fsinfo_fn(ntvfs, req, fs);
 }
 
@@ -71 +71 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->unlink) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->unlink(ntvfs, req, unl);
+        if (!ntvfs->ops->unlink_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->unlink_fn(ntvfs, req, unl);
 }
 
@@ -80 +80 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->chkpath) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->chkpath(ntvfs, req, cp);
+        if (!ntvfs->ops->chkpath_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->chkpath_fn(ntvfs, req, cp);
 }
 
@@ -89 +89 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->qpathinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->qpathinfo(ntvfs, req, st);
+        if (!ntvfs->ops->qpathinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->qpathinfo_fn(ntvfs, req, st);
 }
 
@@ -98 +98 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->setpathinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->setpathinfo(ntvfs, req, st);
+        if (!ntvfs->ops->setpathinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->setpathinfo_fn(ntvfs, req, st);
 }
 
@@ -107 +107 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->open) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->open(ntvfs, req, oi);
+        if (!ntvfs->ops->open_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->open_fn(ntvfs, req, oi);
 }
 
@@ -116 +116 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->mkdir) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->mkdir(ntvfs, req, md);
+        if (!ntvfs->ops->mkdir_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->mkdir_fn(ntvfs, req, md);
 }
 
@@ -125 +125 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->rmdir) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->rmdir(ntvfs, req, rd);
+        if (!ntvfs->ops->rmdir_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->rmdir_fn(ntvfs, req, rd);
 }
 
@@ -134 +134 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->rename) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->rename(ntvfs, req, ren);
+        if (!ntvfs->ops->rename_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->rename_fn(ntvfs, req, ren);
 }
 
@@ -143 +143 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->copy) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->copy(ntvfs, req, cp);
+        if (!ntvfs->ops->copy_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->copy_fn(ntvfs, req, cp);
 }
 
@@ -154 +154 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->search_first) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->search_first(ntvfs, req, io, private_data, ntvfs_callback);
+        if (!ntvfs->ops->search_first_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->search_first_fn(ntvfs, req, io, private_data, ntvfs_callback);
 }
 
@@ -164 +164 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->search_next) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->search_next(ntvfs, req, io, private_data, ntvfs_callback);
+        if (!ntvfs->ops->search_next_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->search_next_fn(ntvfs, req, io, private_data, ntvfs_callback);
 }
 
@@ -173 +173 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->search_close) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->search_close(ntvfs, req, io);
+        if (!ntvfs->ops->search_close_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->search_close_fn(ntvfs, req, io);
 }
 
@@ -183 +183 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->ioctl) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->ioctl(ntvfs, req, io);
+        if (!ntvfs->ops->ioctl_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->ioctl_fn(ntvfs, req, io);
 }
 
@@ -192 +192 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->read) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->read(ntvfs, req, io);
+        if (!ntvfs->ops->read_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->read_fn(ntvfs, req, io);
 }
 
@@ -201 +201 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->write) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->write(ntvfs, req, io);
+        if (!ntvfs->ops->write_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->write_fn(ntvfs, req, io);
 }
 
@@ -210 +210 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->seek) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->seek(ntvfs, req, io);
+        if (!ntvfs->ops->seek_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->seek_fn(ntvfs, req, io);
 }
 
@@ -220 +220 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->flush) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->flush(ntvfs, req, flush);
+        if (!ntvfs->ops->flush_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->flush_fn(ntvfs, req, flush);
 }
 
@@ -229 +229 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->lock) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->lock(ntvfs, req, lck);
+        if (!ntvfs->ops->lock_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->lock_fn(ntvfs, req, lck);
 }
 
@@ -238 +238 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->qfileinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->qfileinfo(ntvfs, req, info);
+        if (!ntvfs->ops->qfileinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->qfileinfo_fn(ntvfs, req, info);
 }
 
@@ -247 +247 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->setfileinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->setfileinfo(ntvfs, req, info);
+        if (!ntvfs->ops->setfileinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->setfileinfo_fn(ntvfs, req, info);
 }
 
@@ -256 +256 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->close) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->close(ntvfs, req, io);
+        if (!ntvfs->ops->close_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->close_fn(ntvfs, req, io);
 }
 
@@ -266 +266 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->trans) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->trans(ntvfs, req, trans);
+        if (!ntvfs->ops->trans_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->trans_fn(ntvfs, req, trans);
 }
 
@@ -276 +276 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->trans2) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->trans2(ntvfs, req, trans2);
+        if (!ntvfs->ops->trans2_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->trans2_fn(ntvfs, req, trans2);
 }
 
@@ -286 +286 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->lpq) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->lpq(ntvfs, req, lpq);
+        if (!ntvfs->ops->lpq_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->lpq_fn(ntvfs, req, lpq);
 }
 
@@ -296 +296 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->logoff) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->logoff(ntvfs, req);
+        if (!ntvfs->ops->logoff_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->logoff_fn(ntvfs, req);
 }
 
@@ -305 +305 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->exit) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->exit(ntvfs, req);
+        if (!ntvfs->ops->exit_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->exit_fn(ntvfs, req);
 }
 
@@ -317 +317 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->notify) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->notify(ntvfs, req, info);
+        if (!ntvfs->ops->notify_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->notify_fn(ntvfs, req, info);
 }
 
@@ -329 +329 @@
 {
         struct ntvfs_module_context *ntvfs = req->ctx->modules;
-        if (!ntvfs->ops->cancel) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->ops->cancel(ntvfs, req);
+        if (!ntvfs->ops->cancel_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->ops->cancel_fn(ntvfs, req);
 }
 
@@ -340 +340 @@
                                      union smb_tcon *tcon)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->connect) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->connect(ntvfs->next, req, tcon);
+        if (!ntvfs->next || !ntvfs->next->ops->connect_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->connect_fn(ntvfs->next, req, tcon);
 }
 
 NTSTATUS ntvfs_next_disconnect(struct ntvfs_module_context *ntvfs)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->disconnect) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->disconnect(ntvfs->next);
+        if (!ntvfs->next || !ntvfs->next->ops->disconnect_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->disconnect_fn(ntvfs->next);
 }
 
@@ -359 +359 @@
                                          void *private_data)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->async_setup) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->async_setup(ntvfs->next, req, private_data);
+        if (!ntvfs->next || !ntvfs->next->ops->async_setup_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->async_setup_fn(ntvfs->next, req, private_data);
 }
 
@@ -370 +370 @@
                                     union smb_fsinfo *fs)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->fsinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->fsinfo(ntvfs->next, req, fs);
+        if (!ntvfs->next || !ntvfs->next->ops->fsinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->fsinfo_fn(ntvfs->next, req, fs);
 }
 
@@ -381 +381 @@
                                     union smb_unlink *unl)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->unlink) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->unlink(ntvfs->next, req, unl);
+        if (!ntvfs->next || !ntvfs->next->ops->unlink_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->unlink_fn(ntvfs->next, req, unl);
 }
 
@@ -391 +391 @@
                                      union smb_chkpath *cp)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->chkpath) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->chkpath(ntvfs->next, req, cp);
+        if (!ntvfs->next || !ntvfs->next->ops->chkpath_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->chkpath_fn(ntvfs->next, req, cp);
 }
 
@@ -401 +401 @@
                                        union smb_fileinfo *st)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->qpathinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->qpathinfo(ntvfs->next, req, st);
+        if (!ntvfs->next || !ntvfs->next->ops->qpathinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->qpathinfo_fn(ntvfs->next, req, st);
 }
 
@@ -411 +411 @@
                                          union smb_setfileinfo *st)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->setpathinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->setpathinfo(ntvfs->next, req, st);
+        if (!ntvfs->next || !ntvfs->next->ops->setpathinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->setpathinfo_fn(ntvfs->next, req, st);
 }
 
@@ -421 +421 @@
                                    union smb_mkdir *md)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->mkdir) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->mkdir(ntvfs->next, req, md);
+        if (!ntvfs->next || !ntvfs->next->ops->mkdir_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->mkdir_fn(ntvfs->next, req, md);
 }
 
@@ -431 +431 @@
                                    struct smb_rmdir *rd)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->rmdir) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->rmdir(ntvfs->next, req, rd);
+        if (!ntvfs->next || !ntvfs->next->ops->rmdir_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->rmdir_fn(ntvfs->next, req, rd);
 }
 
@@ -441 +441 @@
                                     union smb_rename *ren)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->rename) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->rename(ntvfs->next, req, ren);
+        if (!ntvfs->next || !ntvfs->next->ops->rename_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->rename_fn(ntvfs->next, req, ren);
 }
 
@@ -451 +451 @@
                                   struct smb_copy *cp)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->copy) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->copy(ntvfs->next, req, cp);
+        if (!ntvfs->next || !ntvfs->next->ops->copy_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->copy_fn(ntvfs->next, req, cp);
 }
 
@@ -461 +461 @@
                                   union smb_open *oi)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->open) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->open(ntvfs->next, req, oi);
+        if (!ntvfs->next || !ntvfs->next->ops->open_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->open_fn(ntvfs->next, req, oi);
 }
 
@@ -474 +474 @@
                                           bool (*callback)(void *private_data, const union smb_search_data *file))
 {
-        if (!ntvfs->next || !ntvfs->next->ops->search_first) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->search_first(ntvfs->next, req, io, private_data, callback);
+        if (!ntvfs->next || !ntvfs->next->ops->search_first_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->search_first_fn(ntvfs->next, req, io, private_data, callback);
 }
 
@@ -485 +485 @@
                                          bool (*callback)(void *private_data, const union smb_search_data *file))
 {
-        if (!ntvfs->next || !ntvfs->next->ops->search_next) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->search_next(ntvfs->next, req, io, private_data, callback);
+        if (!ntvfs->next || !ntvfs->next->ops->search_next_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->search_next_fn(ntvfs->next, req, io, private_data, callback);
 }
 
@@ -495 +495 @@
                                           union smb_search_close *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->search_close) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->search_close(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->search_close_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->search_close_fn(ntvfs->next, req, io);
 }
 
@@ -506 +506 @@
                                    union smb_ioctl *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->ioctl) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->ioctl(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->ioctl_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->ioctl_fn(ntvfs->next, req, io);
 }
 
@@ -516 +516 @@
                                   union smb_read *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->read) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->read(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->read_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->read_fn(ntvfs->next, req, io);
 }
 
@@ -526 +526 @@
                                    union smb_write *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->write) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->write(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->write_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->write_fn(ntvfs->next, req, io);
 }
 
@@ -536 +536 @@
                                   union smb_seek *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->seek) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->seek(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->seek_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->seek_fn(ntvfs->next, req, io);
 }
 
@@ -546 +546 @@
                                    union smb_flush *flush)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->flush) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->flush(ntvfs->next, req, flush);
+        if (!ntvfs->next || !ntvfs->next->ops->flush_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->flush_fn(ntvfs->next, req, flush);
 }
 
@@ -556 +556 @@
                                   union smb_lock *lck)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->lock) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->lock(ntvfs->next, req, lck);
+        if (!ntvfs->next || !ntvfs->next->ops->lock_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->lock_fn(ntvfs->next, req, lck);
 }
 
@@ -566 +566 @@
                                        union smb_fileinfo *info)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->qfileinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->qfileinfo(ntvfs->next, req, info);
+        if (!ntvfs->next || !ntvfs->next->ops->qfileinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->qfileinfo_fn(ntvfs->next, req, info);
 }
 
@@ -576 +576 @@
                                          union smb_setfileinfo *info)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->setfileinfo) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->setfileinfo(ntvfs->next, req, info);
+        if (!ntvfs->next || !ntvfs->next->ops->setfileinfo_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->setfileinfo_fn(ntvfs->next, req, info);
 }
 
@@ -586 +586 @@
                                    union smb_close *io)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->close) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->close(ntvfs->next, req, io);
+        if (!ntvfs->next || !ntvfs->next->ops->close_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->close_fn(ntvfs->next, req, io);
 }
 
@@ -597 +597 @@
                                    struct smb_trans2 *trans)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->trans) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->trans(ntvfs->next, req, trans);
+        if (!ntvfs->next || !ntvfs->next->ops->trans_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->trans_fn(ntvfs->next, req, trans);
 }
 
@@ -608 +608 @@
                                     struct smb_trans2 *trans2)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->trans2) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->trans2(ntvfs->next, req, trans2);
+        if (!ntvfs->next || !ntvfs->next->ops->trans2_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->trans2_fn(ntvfs->next, req, trans2);
 }
 
@@ -621 +621 @@
                                     union smb_notify *info)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->notify) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->notify(ntvfs->next, req, info);
+        if (!ntvfs->next || !ntvfs->next->ops->notify_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->notify_fn(ntvfs->next, req, info);
 }
 
@@ -631 +631 @@
                                     struct ntvfs_request *req)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->cancel) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->cancel(ntvfs->next, req);
+        if (!ntvfs->next || !ntvfs->next->ops->cancel_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->cancel_fn(ntvfs->next, req);
 }
 
@@ -642 +642 @@
                                  union smb_lpq *lpq)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->lpq) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->lpq(ntvfs->next, req, lpq);
+        if (!ntvfs->next || !ntvfs->next->ops->lpq_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->lpq_fn(ntvfs->next, req, lpq);
 }
 
@@ -653 +653 @@
                                     struct ntvfs_request *req)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->logoff) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->logoff(ntvfs->next, req);
+        if (!ntvfs->next || !ntvfs->next->ops->logoff_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->logoff_fn(ntvfs->next, req);
 }
 
@@ -662 +662 @@
                                   struct ntvfs_request *req)
 {
-        if (!ntvfs->next || !ntvfs->next->ops->exit) {
-                return NT_STATUS_NOT_IMPLEMENTED;
-        }
-        return ntvfs->next->ops->exit(ntvfs->next, req);
+        if (!ntvfs->next || !ntvfs->next->ops->exit_fn) {
+                return NT_STATUS_NOT_IMPLEMENTED;
+        }
+        return ntvfs->next->ops->exit_fn(ntvfs->next, req);
 }
 

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) {

vendor/current/source4/ntvfs/print/vfs_print.c

@@ -23 +23 @@
 
 #include "includes.h"
-#include "libcli/raw/ioctl.h"
+#include "../libcli/smb/smb_constants.h"
 #include "ntvfs/ntvfs.h"
 #include "param/param.h"
+
+NTSTATUS ntvfs_print_init(void);
 
 /*
@@ -114 +116 @@
         
         /* fill in all the operations */
-        ops.connect = print_connect;
-        ops.disconnect = print_disconnect;
-        ops.unlink = print_unlink;
-        ops.ioctl = print_ioctl;
+        ops.connect_fn = print_connect;
+        ops.disconnect_fn = print_disconnect;
+        ops.unlink_fn = print_unlink;
+        ops.ioctl_fn = print_ioctl;
 
         /* register ourselves with the NTVFS subsystem. We register under the name 'default'

vendor/current/source4/ntvfs/simple/svfs_util.c

@@ -39 +39 @@
         struct svfs_private *p = ntvfs->private_data;
         char *ret;
+        char *name_lower = strlower_talloc(p, name);
 
         if (*name != '\\') {
-                ret = talloc_asprintf(req, "%s/%s", p->connectpath, name);
+                ret = talloc_asprintf(req, "%s/%s", p->connectpath, name_lower);
         } else {
-                ret = talloc_asprintf(req, "%s%s", p->connectpath, name);
+                ret = talloc_asprintf(req, "%s%s", p->connectpath, name_lower);
         }
         all_string_sub(ret, "\\", "/", 0);
-
-        strlower(ret + strlen(p->connectpath));
-
+        talloc_free(name_lower);
         return ret;
 }
@@ -83 +82 @@
         mask = p+1;
 
-        low_mask = talloc_strdup(mem_ctx, mask);
+        low_mask = strlower_talloc(mem_ctx, mask);
         if (!low_mask) { return NULL; }
-        strlower(low_mask);
 
         odir = opendir(dir->unix_dir);
@@ -100 +98 @@
                 }
 
-                low_name = talloc_strdup(mem_ctx, dent->d_name);
+                low_name = strlower_talloc(mem_ctx, dent->d_name);
                 if (!low_name) { continue; }
-                strlower(low_name);
 
                 /* check it matches the wildcard pattern */
-                if (ms_fnmatch(low_mask, low_name, PROTOCOL_NT1) != 0) {
+                if (ms_fnmatch_protocol(low_mask, low_name, PROTOCOL_NT1) != 0) {
                         continue;
                 }

vendor/current/source4/ntvfs/simple/vfs_simple.c

@@ -81 +81 @@
         p->ntvfs = ntvfs;
         p->next_search_handle = 0;
-        p->connectpath = talloc_strdup(p, share_string_option(scfg, SHARE_PATH, ""));
+        p->connectpath = share_string_option(p, scfg, SHARE_PATH, "");
         p->open_files = NULL;
         p->search = NULL;
@@ -148 +148 @@
         /* ignoring wildcards ... */
         if (unlink(unix_path) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -177 +177 @@
 
         if (stat(unix_path, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -292 +292 @@
         if (stat(unix_path, &st) == -1) {
                 DEBUG(19,("svfs_qpathinfo: file %s errno=%d\n", unix_path, errno));
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
         DEBUG(19,("svfs_qpathinfo: file %s, stat done\n", unix_path));
@@ -318 +318 @@
         
         if (fstat(f->fd, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -387 +387 @@
                         if (mkdir(unix_path, 0755) == -1) {
                                 DEBUG(9,("svfs_open: mkdir %s errno=%d\n", unix_path, errno));
-                                return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
                         }
                         break;
@@ -393 +393 @@
                         if (mkdir(unix_path, 0755) == -1 && errno != EEXIST) {
                                 DEBUG(9,("svfs_open: mkdir %s errno=%d\n", unix_path, errno));
-                                return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
                         }
                         break;
@@ -402 +402 @@
         fd = open(unix_path, flags, 0644);
         if (fd == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -408 +408 @@
                 DEBUG(9,("svfs_open: fstat errno=%d\n", errno));
                 close(fd);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -415 +415 @@
 
         f = talloc(handle, struct svfs_file);
-        NT_STATUS_HAVE_NO_MEMORY(f);
+        if (f == NULL) {
+                close(fd);
+                return NT_STATUS_NO_MEMORY;
+        }
         f->fd = fd;
         f->name = talloc_strdup(f, unix_path);
@@ -457 +460 @@
 
         if (mkdir(unix_path, 0777) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -476 +479 @@
 
         if (rmdir(unix_path) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -500 +503 @@
 
         if (rename(unix_path1, unix_path2) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
         
@@ -539 +542 @@
                     rd->readx.in.offset);
         if (ret == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -575 +578 @@
                      wr->writex.in.offset);
         if (ret == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
                 
@@ -646 +649 @@
 
         if (close(f->fd) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -736 +739 @@
                 if (ftruncate(f->fd, 
                               info->end_of_file_info.in.size) == -1) {
-                        return map_nt_error_from_unix(errno);
+                        return map_nt_error_from_unix_common(errno);
                 }
                 break;
@@ -782 +785 @@
                         &fs->generic.out.blocks_free, 
                         &fs->generic.out.blocks_total) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -822 +825 @@
 
         if (stat(p->connectpath, &st) == -1) {
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -1059 +1062 @@
 
         /* fill in all the operations */
-        ops.connect = svfs_connect;
-        ops.disconnect = svfs_disconnect;
-        ops.unlink = svfs_unlink;
-        ops.chkpath = svfs_chkpath;
-        ops.qpathinfo = svfs_qpathinfo;
-        ops.setpathinfo = svfs_setpathinfo;
-        ops.open = svfs_open;
-        ops.mkdir = svfs_mkdir;
-        ops.rmdir = svfs_rmdir;
-        ops.rename = svfs_rename;
-        ops.copy = svfs_copy;
-        ops.ioctl = svfs_ioctl;
-        ops.read = svfs_read;
-        ops.write = svfs_write;
-        ops.seek = svfs_seek;
-        ops.flush = svfs_flush; 
-        ops.close = svfs_close;
-        ops.exit = svfs_exit;
-        ops.lock = svfs_lock;
-        ops.setfileinfo = svfs_setfileinfo;
-        ops.qfileinfo = svfs_qfileinfo;
-        ops.fsinfo = svfs_fsinfo;
-        ops.lpq = svfs_lpq;
-        ops.search_first = svfs_search_first;
-        ops.search_next = svfs_search_next;
-        ops.search_close = svfs_search_close;
-        ops.trans = svfs_trans;
-        ops.logoff = svfs_logoff;
-        ops.async_setup = svfs_async_setup;
-        ops.cancel = svfs_cancel;
+        ops.connect_fn = svfs_connect;
+        ops.disconnect_fn = svfs_disconnect;
+        ops.unlink_fn = svfs_unlink;
+        ops.chkpath_fn = svfs_chkpath;
+        ops.qpathinfo_fn = svfs_qpathinfo;
+        ops.setpathinfo_fn = svfs_setpathinfo;
+        ops.open_fn = svfs_open;
+        ops.mkdir_fn = svfs_mkdir;
+        ops.rmdir_fn = svfs_rmdir;
+        ops.rename_fn = svfs_rename;
+        ops.copy_fn = svfs_copy;
+        ops.ioctl_fn = svfs_ioctl;
+        ops.read_fn = svfs_read;
+        ops.write_fn = svfs_write;
+        ops.seek_fn = svfs_seek;
+        ops.flush_fn = svfs_flush;
+        ops.close_fn = svfs_close;
+        ops.exit_fn = svfs_exit;
+        ops.lock_fn = svfs_lock;
+        ops.setfileinfo_fn = svfs_setfileinfo;
+        ops.qfileinfo_fn = svfs_qfileinfo;
+        ops.fsinfo_fn = svfs_fsinfo;
+        ops.lpq_fn = svfs_lpq;
+        ops.search_first_fn = svfs_search_first;
+        ops.search_next_fn = svfs_search_next;
+        ops.search_close_fn = svfs_search_close;
+        ops.trans_fn = svfs_trans;
+        ops.logoff_fn = svfs_logoff;
+        ops.async_setup_fn = svfs_async_setup;
+        ops.cancel_fn = svfs_cancel;
 
         /* register ourselves with the NTVFS subsystem. We register

vendor/current/source4/ntvfs/smb2/vfs_smb2.c

@@ -42 +42 @@
 #include "libcli/smb2/smb2_calls.h"
 
+NTSTATUS ntvfs_smb2_init(void);
+
 struct cvfs_file {
         struct cvfs_file *prev, *next;
@@ -99 +101 @@
   along to the client
  */
+#if 0
 static bool oplock_handler(struct smbcli_transport *transport, uint16_t tid, uint16_t fnum, uint8_t level, void *p_private)
 {
@@ -122 +125 @@
         return true;
 }
+#endif
 
 /*
@@ -161 +165 @@
         struct cvfs_private *p;
         const char *host, *user, *pass, *domain, *remote_share, *sharename;
-        struct composite_context *creq;
         struct share_config *scfg = ntvfs->ctx->config;
         struct smb2_tree *tree;
@@ -167 +170 @@
         bool machine_account;
         struct smbcli_options options;
+        TALLOC_CTX *tmp_ctx;
+
+        tmp_ctx = talloc_new(req);
+        if (tmp_ctx == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
 
         switch (tcon->generic.level) {
@@ -179 +188 @@
                 break;
         default:
-                return NT_STATUS_INVALID_LEVEL;
+                status = NT_STATUS_INVALID_LEVEL;
+                goto out;
         }
 
@@ -191 +201 @@
         /* Here we need to determine which server to connect to.
          * For now we use parametric options, type cifs.
-         * Later we will use security=server and auth_server.c.
          */
-        host = share_string_option(scfg, SMB2_SERVER, NULL);
-        user = share_string_option(scfg, SMB2_USER, NULL);
-        pass = share_string_option(scfg, SMB2_PASSWORD, NULL);
-        domain = share_string_option(scfg, SMB2_DOMAIN, NULL);
-        remote_share = share_string_option(scfg, SMB2_SHARE, NULL);
+        host = share_string_option(tmp_ctx, scfg, SMB2_SERVER, NULL);
+        user = share_string_option(tmp_ctx, scfg, SMB2_USER, NULL);
+        pass = share_string_option(tmp_ctx, scfg, SMB2_PASSWORD, NULL);
+        domain = share_string_option(tmp_ctx, scfg, SMB2_DOMAIN, NULL);
+        remote_share = share_string_option(tmp_ctx, scfg, SMB2_SHARE, NULL);
         if (!remote_share) {
                 remote_share = sharename;
@@ -206 +215 @@
         p = talloc_zero(ntvfs, struct cvfs_private);
         if (!p) {
-                return NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
         }
 
@@ -213 +223 @@
         if (!host) {
                 DEBUG(1,("CIFS backend: You must supply server\n"));
-                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto out;
         } 
         
@@ -220 +231 @@
                 credentials = cli_credentials_init(p);
                 if (!credentials) {
-                        return NT_STATUS_NO_MEMORY;
+                        status = NT_STATUS_NO_MEMORY;
+                        goto out;
                 }
                 cli_credentials_set_conf(credentials, ntvfs->ctx->lp_ctx);
@@ -237 +249 @@
                 status = cli_credentials_set_machine_account(credentials, ntvfs->ctx->lp_ctx);
                 if (!NT_STATUS_IS_OK(status)) {
-                        return status;
+                        goto out;
                 }
         } else if (req->session_info->credentials) {
@@ -244 +256 @@
         } else {
                 DEBUG(1,("CIFS backend: NO delegated credentials found: You must supply server, user and password or the client must supply delegated credentials\n"));
-                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto out;
         }
 
         lpcfg_smbcli_options(ntvfs->ctx->lp_ctx, &options);
 
-        creq = smb2_connect_send(p, host,
+        status = smb2_connect(p, host,
                         lpcfg_parm_string_list(p, ntvfs->ctx->lp_ctx, NULL, "smb2", "ports", NULL),
-                                remote_share, 
-                                 lpcfg_resolve_context(ntvfs->ctx->lp_ctx),
-                                 credentials,
-                                 ntvfs->ctx->event_ctx, &options,
-                                 lpcfg_socket_options(ntvfs->ctx->lp_ctx),
-                                 lpcfg_gensec_settings(p, ntvfs->ctx->lp_ctx)
-                                 );
-
-        status = smb2_connect_recv(creq, p, &tree);
-        NT_STATUS_NOT_OK_RETURN(status);
+                        remote_share,
+                        lpcfg_resolve_context(ntvfs->ctx->lp_ctx),
+                        credentials,
+                        &tree,
+                        ntvfs->ctx->event_ctx, &options,
+                        lpcfg_socket_options(ntvfs->ctx->lp_ctx),
+                        lpcfg_gensec_settings(p, ntvfs->ctx->lp_ctx));
+        if (!NT_STATUS_IS_OK(status)) {
+                goto out;
+        }
 
         status = smb2_get_roothandle(tree, &p->roothandle);
-        NT_STATUS_NOT_OK_RETURN(status);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto out;
+        }
 
         p->tree = tree;
@@ -270 +285 @@
 
         ntvfs->ctx->fs_type = talloc_strdup(ntvfs->ctx, "NTFS");
-        NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->fs_type);
+        if (ntvfs->ctx->fs_type == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
         ntvfs->ctx->dev_type = talloc_strdup(ntvfs->ctx, "A:");
-        NT_STATUS_HAVE_NO_MEMORY(ntvfs->ctx->dev_type);
+        if (ntvfs->ctx->dev_type == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto out;
+        }
 
         if (tcon->generic.level == RAW_TCON_TCONX) {
@@ -283 +304 @@
         smbcli_oplock_handler(p->transport, oplock_handler, p);
         */
-        return NT_STATUS_OK;
+
+        status = NT_STATUS_OK;
+
+out:
+        TALLOC_FREE(tmp_ctx);
+        return status;
 }
 
@@ -835 +861 @@
         
         /* fill in all the operations */
-        ops.connect = cvfs_connect;
-        ops.disconnect = cvfs_disconnect;
-        ops.unlink = cvfs_unlink;
-        ops.chkpath = cvfs_chkpath;
-        ops.qpathinfo = cvfs_qpathinfo;
-        ops.setpathinfo = cvfs_setpathinfo;
-        ops.open = cvfs_open;
-        ops.mkdir = cvfs_mkdir;
-        ops.rmdir = cvfs_rmdir;
-        ops.rename = cvfs_rename;
-        ops.copy = cvfs_copy;
-        ops.ioctl = cvfs_ioctl;
-        ops.read = cvfs_read;
-        ops.write = cvfs_write;
-        ops.seek = cvfs_seek;
-        ops.flush = cvfs_flush; 
-        ops.close = cvfs_close;
-        ops.exit = cvfs_exit;
-        ops.lock = cvfs_lock;
-        ops.setfileinfo = cvfs_setfileinfo;
-        ops.qfileinfo = cvfs_qfileinfo;
-        ops.fsinfo = cvfs_fsinfo;
-        ops.lpq = cvfs_lpq;
-        ops.search_first = cvfs_search_first;
-        ops.search_next = cvfs_search_next;
-        ops.search_close = cvfs_search_close;
-        ops.trans = cvfs_trans;
-        ops.logoff = cvfs_logoff;
-        ops.async_setup = cvfs_async_setup;
-        ops.cancel = cvfs_cancel;
-        ops.notify = cvfs_notify;
+        ops.connect_fn = cvfs_connect;
+        ops.disconnect_fn = cvfs_disconnect;
+        ops.unlink_fn = cvfs_unlink;
+        ops.chkpath_fn = cvfs_chkpath;
+        ops.qpathinfo_fn = cvfs_qpathinfo;
+        ops.setpathinfo_fn = cvfs_setpathinfo;
+        ops.open_fn = cvfs_open;
+        ops.mkdir_fn = cvfs_mkdir;
+        ops.rmdir_fn = cvfs_rmdir;
+        ops.rename_fn = cvfs_rename;
+        ops.copy_fn = cvfs_copy;
+        ops.ioctl_fn = cvfs_ioctl;
+        ops.read_fn = cvfs_read;
+        ops.write_fn = cvfs_write;
+        ops.seek_fn = cvfs_seek;
+        ops.flush_fn = cvfs_flush;
+        ops.close_fn = cvfs_close;
+        ops.exit_fn = cvfs_exit;
+        ops.lock_fn = cvfs_lock;
+        ops.setfileinfo_fn = cvfs_setfileinfo;
+        ops.qfileinfo_fn = cvfs_qfileinfo;
+        ops.fsinfo_fn = cvfs_fsinfo;
+        ops.lpq_fn = cvfs_lpq;
+        ops.search_first_fn = cvfs_search_first;
+        ops.search_next_fn = cvfs_search_next;
+        ops.search_close_fn = cvfs_search_close;
+        ops.trans_fn = cvfs_trans;
+        ops.logoff_fn = cvfs_logoff;
+        ops.async_setup_fn = cvfs_async_setup;
+        ops.cancel_fn = cvfs_cancel;
+        ops.notify_fn = cvfs_notify;
 
         /* register ourselves with the NTVFS subsystem. We register

vendor/current/source4/ntvfs/sysdep/inotify.c

@@ -30 +30 @@
 #include "param/param.h"
 
-#if HAVE_SYS_INOTIFY_H
 #include <sys/inotify.h>
-#else
-/* for older glibc varients - we can remove this eventually */
-#include <linux/inotify.h>
-#include <asm/unistd.h>
-
-#ifndef HAVE_INOTIFY_INIT
-/*
-  glibc doesn't define these functions yet (as of March 2006)
-*/
-static int inotify_init(void)
-{
-        return syscall(__NR_inotify_init);
-}
-
-static int inotify_add_watch(int fd, const char *path, __u32 mask)
-{
-        return syscall(__NR_inotify_add_watch, fd, path, mask);
-}
-
-static int inotify_rm_watch(int fd, int wd)
-{
-        return syscall(__NR_inotify_rm_watch, fd, wd);
-}
-#endif
-#endif
-
-
-/* older glibc headers don't have these defines either */
+
+/* glibc < 2.5 headers don't have these defines */
 #ifndef IN_ONLYDIR
 #define IN_ONLYDIR 0x01000000
@@ -172 +145 @@
                 next = w->next;
                 if (w->wd == e->wd && filter_match(w, e)) {
+                        ne.dir = w->path;
                         w->callback(in->ctx, w->private_data, &ne);
                 }
@@ -191 +165 @@
                 if (w->wd == e->wd && filter_match(w, e) &&
                     !(w->filter & FILE_NOTIFY_CHANGE_CREATION)) {
+                        ne.dir = w->path;
                         w->callback(in->ctx, w->private_data, &ne);
                 }
@@ -259 +234 @@
                 DEBUG(0,("Failed to init inotify - %s\n", strerror(errno)));
                 talloc_free(in);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
         in->ctx = ctx;
@@ -275 +250 @@
                 DEBUG(0,("Failed to tevent_add_fd() - %s\n", strerror(errno)));
                 talloc_free(in);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -374 +349 @@
         if (wd == -1) {
                 e->filter = filter;
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -416 +391 @@
   initialialise the inotify module
  */
+NTSTATUS sys_notify_inotify_init(void);
 NTSTATUS sys_notify_inotify_init(void)
 {

vendor/current/source4/ntvfs/sysdep/sys_lease.c

@@ -28 +28 @@
 #include "../lib/util/dlinklist.h"
 #include "param/param.h"
+#include "lib/util/samba_modules.h"
 
 /* list of registered backends */
@@ -41 +42 @@
                                                             TALLOC_CTX *mem_ctx,
                                                             struct tevent_context *ev,
-                                                            struct messaging_context *msg,
+                                                            struct imessaging_context *msg,
                                                             sys_lease_send_break_fn break_send)
 {
@@ -48 +49 @@
         int i;
         NTSTATUS status;
+        TALLOC_CTX * tmp_ctx;
 
         if (num_backends == 0) {
@@ -62 +64 @@
         }
 
+        tmp_ctx = talloc_new(ctx);
+        if (tmp_ctx == NULL) {
+                return NULL;
+        }
+
         ctx->event_ctx = ev;
         ctx->msg_ctx = msg;
         ctx->break_send = break_send;
 
-        bname = share_string_option(scfg, LEASE_BACKEND, NULL);
+        bname = share_string_option(tmp_ctx, scfg, LEASE_BACKEND, NULL);
         if (!bname) {
                 talloc_free(ctx);
@@ -90 +97 @@
         }
 
+        TALLOC_FREE(tmp_ctx);
         return ctx;
 }

vendor/current/source4/ntvfs/sysdep/sys_lease.h

@@ -22 +22 @@
 struct sys_lease_context;
 struct opendb_entry;
-struct messaging_context;
+struct imessaging_context;
 struct tevent_context;
 
-typedef NTSTATUS (*sys_lease_send_break_fn)(struct messaging_context *,
+typedef NTSTATUS (*sys_lease_send_break_fn)(struct imessaging_context *,
                                             struct opendb_entry *,
                                             uint8_t level);
@@ -42 +42 @@
 struct sys_lease_context {
         struct tevent_context *event_ctx;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         sys_lease_send_break_fn break_send;
         void *private_data; /* for use of backend */
@@ -54 +54 @@
                                                    TALLOC_CTX *mem_ctx,
                                                    struct tevent_context *ev,
-                                                   struct messaging_context *msg_ctx,
+                                                   struct imessaging_context *msg_ctx,
                                                    sys_lease_send_break_fn break_send);
 

vendor/current/source4/ntvfs/sysdep/sys_lease_linux.c

@@ -30 +30 @@
 #include "../lib/util/dlinklist.h"
 #include "cluster/cluster.h"
+
+NTSTATUS sys_lease_linux_init(void);
 
 #define LINUX_LEASE_RT_SIGNAL (SIGRTMIN+1)
@@ -130 +132 @@
         if (ret == -1) {
                 talloc_free(p);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 
@@ -136 +138 @@
         if (ret == -1) {
                 talloc_free(p);
-                return map_nt_error_from_unix(errno);
+                return map_nt_error_from_unix_common(errno);
         }
 

vendor/current/source4/ntvfs/sysdep/sys_notify.c

@@ -29 +29 @@
 #include "../lib/util/dlinklist.h"
 #include "param/param.h"
+#include "lib/util/samba_modules.h"
 
 /* list of registered backends */
@@ -62 +63 @@
         ctx->ev = ev;
 
-        bname = share_string_option(scfg, NOTIFY_BACKEND, NULL);
+        bname = share_string_option(ctx, scfg, NOTIFY_BACKEND, NULL);
         if (!bname) {
                 if (num_backends) {

vendor/current/source4/ntvfs/sysdep/sys_notify.h

@@ -18 +18 @@
 */
 
-#include "librpc/gen_ndr/s4_notify.h"
+#include "librpc/gen_ndr/notify.h"
 #include "param/share.h"
 

vendor/current/source4/ntvfs/sysdep/wscript_build

@@ -5 +5 @@
                  subsystem='sys_notify',
                  init_function='sys_notify_inotify_init',
-                 deps='events',
+                 deps='events inotify',
                  enabled = bld.CONFIG_SET('HAVE_LINUX_INOTIFY')
                  )

vendor/current/source4/ntvfs/sysdep/wscript_configure

@@ -1 +1 @@
 #!/usr/bin/env python
 
-conf.CHECK_HEADERS('linux/inotify.h asm/unistd.h sys/inotify.h', add_headers=False)
+import sys
 
-conf.CHECK_FUNCS('inotify_init')
+# Check for inotify support (Skip if we are SunOS)
+#NOTE: illumos provides sys/inotify.h but is not an exact match for linux
+host_os = sys.platform
+if host_os.rfind('sunos') == -1:
+    conf.CHECK_HEADERS('sys/inotify.h', add_headers=False)
+    if (conf.CONFIG_SET('HAVE_SYS_INOTIFY_H')):
+        conf.DEFINE('HAVE_LINUX_INOTIFY', 1)
 
-conf.CHECK_VARIABLE('__NR_inotify_init')
 conf.CHECK_DECLS('F_SETLEASE', headers='linux/fcntl.h', reverse=True)
 conf.CHECK_DECLS('SA_SIGINFO', headers='signal.h', reverse=True)
-
-conf.CHECK_DECLS('__NR_inotify_init', reverse=True, headers='asm/unistd.h')
-
-if (conf.CONFIG_SET('HAVE___NR_INOTIFY_INIT') and
-    (conf.CONFIG_SET('HAVE_LINUX_INOTIFY_H') or
-     conf.CONFIG_SET('HAVE_SYS_INOTIFY_H'))):
-    conf.DEFINE('HAVE_LINUX_INOTIFY', 1)

vendor/current/source4/ntvfs/unixuid/vfs_unixuid.c

@@ -29 +29 @@
 #define TEVENT_DEPRECATED
 #include <tevent.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/setid.h"
+
+NTSTATUS ntvfs_unixuid_init(void);
 
 struct unixuid_private {
-        struct wbc_context *wbc_ctx;
-        struct unix_sec_ctx *last_sec_ctx;
+        struct security_unix_token *last_sec_ctx;
         struct security_token *last_token;
 };
 
 
-
-struct unix_sec_ctx {
-        uid_t uid;
-        gid_t gid;
-        unsigned int ngroups;
-        gid_t *groups;
-};
-
-/*
-  pull the current security context into a unix_sec_ctx
-*/
-static struct unix_sec_ctx *save_unix_security(TALLOC_CTX *mem_ctx)
-{
-        struct unix_sec_ctx *sec = talloc(mem_ctx, struct unix_sec_ctx);
+/*
+  pull the current security context into a security_unix_token
+*/
+static struct security_unix_token *save_unix_security(TALLOC_CTX *mem_ctx)
+{
+        struct security_unix_token *sec = talloc(mem_ctx, struct security_unix_token);
         if (sec == NULL) {
                 return NULL;
@@ -86 +70 @@
 
 /*
-  set the current security context from a unix_sec_ctx
-*/
-static NTSTATUS set_unix_security(struct unix_sec_ctx *sec)
-{
-        seteuid(0);
-
-        if (setgroups(sec->ngroups, sec->groups) != 0) {
+  set the current security context from a security_unix_token
+*/
+static NTSTATUS set_unix_security(struct security_unix_token *sec)
+{
+        samba_seteuid(0);
+
+        if (samba_setgroups(sec->ngroups, sec->groups) != 0) {
+                DBG_ERR("*** samba_setgroups failed\n");
                 return NT_STATUS_ACCESS_DENIED;
         }
-        if (setegid(sec->gid) != 0) {
+        if (samba_setegid(sec->gid) != 0) {
+                DBG_ERR("*** samba_setegid(%u) failed\n", sec->gid);
                 return NT_STATUS_ACCESS_DENIED;
         }
-        if (seteuid(sec->uid) != 0) {
+        if (samba_seteuid(sec->uid) != 0) {
+                DBG_ERR("*** samba_seteuid(%u) failed\n", sec->uid);
                 return NT_STATUS_ACCESS_DENIED;
         }
@@ -117 +104 @@
                                       const char *location)
 {
-        struct unix_sec_ctx *sec_ctx;
+        struct security_unix_token *sec_ctx;
 
         if (unixuid_nesting_level == 0) {
@@ -131 +118 @@
                         return -1;
                 }
-                *(struct unix_sec_ctx **)stack_ptr = sec_ctx;
-                if (seteuid(0) != 0 || setegid(0) != 0) {
+                *(struct security_unix_token **)stack_ptr = sec_ctx;
+                if (samba_seteuid(0) != 0 || samba_setegid(0) != 0) {
                         DEBUG(0,("%s: Failed to change to root\n", location));
                         return -1;                      
@@ -140 +127 @@
                 NTSTATUS status;
 
-                sec_ctx = *(struct unix_sec_ctx **)stack_ptr;
+                sec_ctx = *(struct security_unix_token **)stack_ptr;
                 if (sec_ctx == NULL) {
                         /* this happens the first time this function
@@ -148 +135 @@
                 }
 
-                sec_ctx = talloc_get_type_abort(sec_ctx, struct unix_sec_ctx);
+                sec_ctx = talloc_get_type_abort(sec_ctx, struct security_unix_token);
                 status = set_unix_security(sec_ctx);
                 talloc_free(sec_ctx);
@@ -163 +150 @@
 
 /*
-  form a unix_sec_ctx from the current security_token
+  form a security_unix_token from the current security_token
 */
 static NTSTATUS nt_token_to_unix_security(struct ntvfs_module_context *ntvfs,
                                           struct ntvfs_request *req,
                                           struct security_token *token,
-                                          struct unix_sec_ctx **sec)
-{
-        struct unixuid_private *priv = ntvfs->private_data;
-        int i;
-        NTSTATUS status;
-        struct id_map *ids;
-        struct composite_context *ctx;
-        *sec = talloc(req, struct unix_sec_ctx);
-
-        /* we can't do unix security without a user and group */
-        if (token->num_sids < 2) {
-                return NT_STATUS_ACCESS_DENIED;
-        }
-
-        ids = talloc_array(req, struct id_map, token->num_sids);
-        NT_STATUS_HAVE_NO_MEMORY(ids);
-
-        (*sec)->ngroups = token->num_sids - 2;
-        (*sec)->groups = talloc_array(*sec, gid_t, (*sec)->ngroups);
-        NT_STATUS_HAVE_NO_MEMORY((*sec)->groups);
-
-        for (i=0;i<token->num_sids;i++) {
-                ZERO_STRUCT(ids[i].xid);
-                ids[i].sid = &token->sids[i];
-                ids[i].status = ID_UNKNOWN;
-        }
-
-        ctx = wbc_sids_to_xids_send(priv->wbc_ctx, ids, token->num_sids, ids);
-        NT_STATUS_HAVE_NO_MEMORY(ctx);
-
-        status = wbc_sids_to_xids_recv(ctx, &ids);
-        NT_STATUS_NOT_OK_RETURN(status);
-
-        if (ids[0].xid.type == ID_TYPE_BOTH ||
-            ids[0].xid.type == ID_TYPE_UID) {
-                (*sec)->uid = ids[0].xid.id;
-        } else {
-                return NT_STATUS_INVALID_SID;
-        }
-
-        if (ids[1].xid.type == ID_TYPE_BOTH ||
-            ids[1].xid.type == ID_TYPE_GID) {
-                (*sec)->gid = ids[1].xid.id;
-        } else {
-                return NT_STATUS_INVALID_SID;
-        }
-
-        for (i=0;i<(*sec)->ngroups;i++) {
-                if (ids[i+2].xid.type == ID_TYPE_BOTH ||
-                    ids[i+2].xid.type == ID_TYPE_GID) {
-                        (*sec)->groups[i] = ids[i+2].xid.id;
-                } else {
-                        return NT_STATUS_INVALID_SID;
-                }
-        }
-
-        return NT_STATUS_OK;
+                                          struct security_unix_token **sec)
+{
+        return security_token_to_unix_token(req,
+                                            ntvfs->ctx->event_ctx,
+                                            token, sec);
 }
 
@@ -231 +166 @@
 */
 static NTSTATUS unixuid_setup_security(struct ntvfs_module_context *ntvfs,
-                                       struct ntvfs_request *req, struct unix_sec_ctx **sec)
+                                       struct ntvfs_request *req, struct security_unix_token **sec)
 {
         struct unixuid_private *priv = ntvfs->private_data;
         struct security_token *token;
-        struct unix_sec_ctx *newsec;
+        struct security_unix_token *newsec;
         NTSTATUS status;
 
@@ -282 +217 @@
 #define PASS_THRU_REQ(ntvfs, req, op, args) do { \
         NTSTATUS status2; \
-        struct unix_sec_ctx *sec; \
+        struct security_unix_token *sec; \
         status = unixuid_setup_security(ntvfs, req, &sec); \
         NT_STATUS_NOT_OK_RETURN(status); \
@@ -309 +244 @@
         }
 
-        priv->wbc_ctx = wbc_init(priv, ntvfs->ctx->msg_ctx,
-                                    ntvfs->ctx->event_ctx);
-        if (priv->wbc_ctx == NULL) {
-                talloc_free(priv);
-                return NT_STATUS_INTERNAL_ERROR;
-        }
-
         priv->last_sec_ctx = NULL;
         priv->last_token = NULL;
@@ -747 +675 @@
 
         /* fill in all the operations */
-        ops.connect = unixuid_connect;
-        ops.disconnect = unixuid_disconnect;
-        ops.unlink = unixuid_unlink;
-        ops.chkpath = unixuid_chkpath;
-        ops.qpathinfo = unixuid_qpathinfo;
-        ops.setpathinfo = unixuid_setpathinfo;
-        ops.open = unixuid_open;
-        ops.mkdir = unixuid_mkdir;
-        ops.rmdir = unixuid_rmdir;
-        ops.rename = unixuid_rename;
-        ops.copy = unixuid_copy;
-        ops.ioctl = unixuid_ioctl;
-        ops.read = unixuid_read;
-        ops.write = unixuid_write;
-        ops.seek = unixuid_seek;
-        ops.flush = unixuid_flush;      
-        ops.close = unixuid_close;
-        ops.exit = unixuid_exit;
-        ops.lock = unixuid_lock;
-        ops.setfileinfo = unixuid_setfileinfo;
-        ops.qfileinfo = unixuid_qfileinfo;
-        ops.fsinfo = unixuid_fsinfo;
-        ops.lpq = unixuid_lpq;
-        ops.search_first = unixuid_search_first;
-        ops.search_next = unixuid_search_next;
-        ops.search_close = unixuid_search_close;
-        ops.trans = unixuid_trans;
-        ops.logoff = unixuid_logoff;
-        ops.async_setup = unixuid_async_setup;
-        ops.cancel = unixuid_cancel;
-        ops.notify = unixuid_notify;
+        ops.connect_fn = unixuid_connect;
+        ops.disconnect_fn = unixuid_disconnect;
+        ops.unlink_fn = unixuid_unlink;
+        ops.chkpath_fn = unixuid_chkpath;
+        ops.qpathinfo_fn = unixuid_qpathinfo;
+        ops.setpathinfo_fn = unixuid_setpathinfo;
+        ops.open_fn = unixuid_open;
+        ops.mkdir_fn = unixuid_mkdir;
+        ops.rmdir_fn = unixuid_rmdir;
+        ops.rename_fn = unixuid_rename;
+        ops.copy_fn = unixuid_copy;
+        ops.ioctl_fn = unixuid_ioctl;
+        ops.read_fn = unixuid_read;
+        ops.write_fn = unixuid_write;
+        ops.seek_fn = unixuid_seek;
+        ops.flush_fn = unixuid_flush;
+        ops.close_fn = unixuid_close;
+        ops.exit_fn = unixuid_exit;
+        ops.lock_fn = unixuid_lock;
+        ops.setfileinfo_fn = unixuid_setfileinfo;
+        ops.qfileinfo_fn = unixuid_qfileinfo;
+        ops.fsinfo_fn = unixuid_fsinfo;
+        ops.lpq_fn = unixuid_lpq;
+        ops.search_first_fn = unixuid_search_first;
+        ops.search_next_fn = unixuid_search_next;
+        ops.search_close_fn = unixuid_search_close;
+        ops.trans_fn = unixuid_trans;
+        ops.logoff_fn = unixuid_logoff;
+        ops.async_setup_fn = unixuid_async_setup;
+        ops.cancel_fn = unixuid_cancel;
+        ops.notify_fn = unixuid_notify;
 
         ops.name = "unixuid";

vendor/current/source4/ntvfs/unixuid/wscript_build

@@ -5 +5 @@
         subsystem='ntvfs',
         init_function='ntvfs_unixuid_init',
-        deps='samdb'
+        deps='auth_unix_token talloc'
         )
 

vendor/current/source4/ntvfs/wscript_build

@@ -1 +1 @@
 #!/usr/bin/env python
 
-bld.RECURSE('posix')
-bld.RECURSE('common')
-bld.RECURSE('unixuid')
-bld.RECURSE('sysdep')
+bld.SAMBA_LIBRARY('ntvfs',
+                  source='ntvfs_base.c ntvfs_generic.c ntvfs_interface.c ntvfs_util.c',
+                  autoproto='ntvfs_proto.h',
+                  deps='tevent samba-modules',
+                  private_library=True,
+                  enabled=bld.AD_DC_BUILD_IS_ENABLED()
+                  )
+
+if bld.AD_DC_BUILD_IS_ENABLED():
+    bld.RECURSE('posix')
+    bld.RECURSE('common')
+    bld.RECURSE('unixuid')
+    bld.RECURSE('sysdep')
 
 bld.SAMBA_MODULE('ntvfs_cifs',
@@ -10 +19 @@
         subsystem='ntvfs',
         init_function='ntvfs_cifs_init',
-        deps='LIBCLI_SMB LIBCLI_RAW'
+        deps='LIBCLI_SMB smbclient-raw param_options'
         )
 
@@ -18 +27 @@
         subsystem='ntvfs',
         init_function='ntvfs_smb2_init',
-        deps='LIBCLI_SMB LIBCLI_RAW'
+        deps='LIBCLI_SMB smbclient-raw param_options'
         )
 
@@ -53 +62 @@
         subsystem='ntvfs',
         init_function='ntvfs_ipc_init',
-        deps='NDR_NAMED_PIPE_AUTH NAMED_PIPE_AUTH_TSTREAM gssapi credentials DCERPC_SHARE'
+        deps='NDR_NAMED_PIPE_AUTH npa_tstream gssapi samba-credentials DCERPC_SHARE'
         )
 
@@ -65 +74 @@
 
 
-bld.SAMBA_LIBRARY('ntvfs',
-                  source='ntvfs_base.c ntvfs_generic.c ntvfs_interface.c ntvfs_util.c',
-                  autoproto='ntvfs_proto.h',
-                  deps='tevent',
-                  private_library=True
-                  )
-