2 Unix SMB/Netbios implementation.
4 VFS initialisation and support functions
5 Copyright (C) Tim Potter 1999
6 Copyright (C) Alexander Bokovoy 2002
7 Copyright (C) James Peach 2006
8 Copyright (C) Volker Lendecke 2009
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 This work was sponsored by Optifacio Software Services, Inc.
27 #include "system/filesys.h"
28 #include "smbd/smbd.h"
29 #include "smbd/globals.h"
30 #include "../lib/util/memcache.h"
31 #include "transfer_file.h"
33 #include "lib/util/tevent_unix.h"
36 #define DBGC_CLASS DBGC_VFS
41 struct vfs_fsp_data *next;
42 struct vfs_handle_struct *owner;
43 void (*destroy)(void *p_data);
45 /* NOTE: This structure contains four pointers so that we can guarantee
46 * that the end of the structure is always both 4-byte and 8-byte aligned.
50 struct vfs_init_function_entry {
52 struct vfs_init_function_entry *prev, *next;
53 const struct vfs_fn_pointers *fns;
56 /****************************************************************************
57 maintain the list of available backends
58 ****************************************************************************/
60 static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
62 struct vfs_init_function_entry *entry = backends;
64 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name));
67 if (strcmp(entry->name, name)==0) return entry;
74 NTSTATUS smb_register_vfs(int version, const char *name,
75 const struct vfs_fn_pointers *fns)
77 struct vfs_init_function_entry *entry = backends;
79 if ((version != SMB_VFS_INTERFACE_VERSION)) {
80 DEBUG(0, ("Failed to register vfs module.\n"
81 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
82 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
83 "Please recompile against the current Samba Version!\n",
84 version, SMB_VFS_INTERFACE_VERSION));
85 return NT_STATUS_OBJECT_TYPE_MISMATCH;
88 if (!name || !name[0]) {
89 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
90 return NT_STATUS_INVALID_PARAMETER;
93 if (vfs_find_backend_entry(name)) {
94 DEBUG(0,("VFS module %s already loaded!\n", name));
95 return NT_STATUS_OBJECT_NAME_COLLISION;
98 entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
99 entry->name = smb_xstrdup(name);
102 DLIST_ADD(backends, entry);
103 DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
107 /****************************************************************************
108 initialise default vfs hooks
109 ****************************************************************************/
111 static void vfs_init_default(connection_struct *conn)
113 DEBUG(3, ("Initialising default vfs hooks\n"));
114 vfs_init_custom(conn, DEFAULT_VFS_MODULE_NAME);
117 /****************************************************************************
118 initialise custom vfs hooks
119 ****************************************************************************/
121 bool vfs_init_custom(connection_struct *conn, const char *vfs_object)
123 char *module_path = NULL;
124 char *module_name = NULL;
125 char *module_param = NULL, *p;
126 vfs_handle_struct *handle;
127 const struct vfs_init_function_entry *entry;
129 if (!conn||!vfs_object||!vfs_object[0]) {
130 DEBUG(0, ("vfs_init_custom() called with NULL pointer or "
131 "empty vfs_object!\n"));
136 static_init_vfs(NULL);
139 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
141 module_path = smb_xstrdup(vfs_object);
143 p = strchr_m(module_path, ':');
148 trim_char(module_param, ' ', ' ');
151 trim_char(module_path, ' ', ' ');
153 module_name = smb_xstrdup(module_path);
155 if ((module_name[0] == '/') &&
156 (strcmp(module_path, DEFAULT_VFS_MODULE_NAME) != 0)) {
159 * Extract the module name from the path. Just use the base
160 * name of the last path component.
163 SAFE_FREE(module_name);
164 module_name = smb_xstrdup(strrchr_m(module_path, '/')+1);
166 p = strchr_m(module_name, '.');
173 /* First, try to load the module with the new module system */
174 entry = vfs_find_backend_entry(module_name);
178 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
181 status = smb_load_module("vfs", module_path);
182 if (!NT_STATUS_IS_OK(status)) {
183 DEBUG(0, ("error probing vfs module '%s': %s\n",
184 module_path, nt_errstr(status)));
188 entry = vfs_find_backend_entry(module_name);
190 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
195 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
197 handle = talloc_zero(conn, vfs_handle_struct);
199 DEBUG(0,("TALLOC_ZERO() failed!\n"));
203 handle->fns = entry->fns;
205 handle->param = talloc_strdup(conn, module_param);
207 DLIST_ADD(conn->vfs_handles, handle);
209 SAFE_FREE(module_path);
210 SAFE_FREE(module_name);
214 SAFE_FREE(module_path);
215 SAFE_FREE(module_name);
219 /*****************************************************************
220 Allow VFS modules to extend files_struct with VFS-specific state.
221 This will be ok for small numbers of extensions, but might need to
222 be refactored if it becomes more widely used.
223 ******************************************************************/
225 #define EXT_DATA_AREA(e) ((uint8_t *)(e) + sizeof(struct vfs_fsp_data))
227 void *vfs_add_fsp_extension_notype(vfs_handle_struct *handle,
228 files_struct *fsp, size_t ext_size,
229 void (*destroy_fn)(void *p_data))
231 struct vfs_fsp_data *ext;
234 /* Prevent VFS modules adding multiple extensions. */
235 if ((ext_data = vfs_fetch_fsp_extension(handle, fsp))) {
239 ext = (struct vfs_fsp_data *)TALLOC_ZERO(
240 handle->conn, sizeof(struct vfs_fsp_data) + ext_size);
246 ext->next = fsp->vfs_extension;
247 ext->destroy = destroy_fn;
248 fsp->vfs_extension = ext;
249 return EXT_DATA_AREA(ext);
252 void vfs_remove_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
254 struct vfs_fsp_data *curr;
255 struct vfs_fsp_data *prev;
257 for (curr = fsp->vfs_extension, prev = NULL;
259 prev = curr, curr = curr->next) {
260 if (curr->owner == handle) {
262 prev->next = curr->next;
264 fsp->vfs_extension = curr->next;
267 curr->destroy(EXT_DATA_AREA(curr));
275 void vfs_remove_all_fsp_extensions(files_struct *fsp)
277 struct vfs_fsp_data *curr;
278 struct vfs_fsp_data *next;
280 for (curr = fsp->vfs_extension; curr; curr = next) {
283 fsp->vfs_extension = next;
286 curr->destroy(EXT_DATA_AREA(curr));
292 void *vfs_memctx_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
294 struct vfs_fsp_data *head;
296 for (head = fsp->vfs_extension; head; head = head->next) {
297 if (head->owner == handle) {
305 void *vfs_fetch_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
307 struct vfs_fsp_data *head;
309 head = (struct vfs_fsp_data *)vfs_memctx_fsp_extension(handle, fsp);
311 return EXT_DATA_AREA(head);
320 * Ensure this module catches all VFS functions.
323 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers* fns,
326 bool missing_fn = false;
328 const uintptr_t *end = (const uintptr_t *)(fns + 1);
330 for (idx = 0; ((const uintptr_t *)fns + idx) < end; idx++) {
331 if (*((const uintptr_t *)fns + idx) == 0) {
332 DBG_ERR("VFS function at index %d not implemented "
333 "in module %s\n", idx, module);
339 smb_panic("Required VFS function not implemented in module.\n");
343 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers* fns,
349 /*****************************************************************
351 ******************************************************************/
353 bool smbd_vfs_init(connection_struct *conn)
355 const char **vfs_objects;
359 /* Normal share - initialise with disk access functions */
360 vfs_init_default(conn);
362 /* No need to load vfs modules for printer connections */
367 vfs_objects = lp_vfs_objects(SNUM(conn));
369 /* Override VFS functions if 'vfs object' was not specified*/
370 if (!vfs_objects || !vfs_objects[0])
373 for (i=0; vfs_objects[i] ;) {
377 for (j=i-1; j >= 0; j--) {
378 if (!vfs_init_custom(conn, vfs_objects[j])) {
379 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
386 /*******************************************************************
387 Check if a file exists in the vfs.
388 ********************************************************************/
390 NTSTATUS vfs_file_exist(connection_struct *conn, struct smb_filename *smb_fname)
392 /* Only return OK if stat was successful and S_ISREG */
393 if ((SMB_VFS_STAT(conn, smb_fname) != -1) &&
394 S_ISREG(smb_fname->st.st_ex_mode)) {
398 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
401 /****************************************************************************
402 Read data from fsp on the vfs. (note: EINTR re-read differs from vfs_write_data)
403 ****************************************************************************/
405 ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count)
409 while (total < byte_count)
411 ssize_t ret = SMB_VFS_READ(fsp, buf + total,
414 if (ret == 0) return total;
423 return (ssize_t)total;
426 /****************************************************************************
427 Write data to a fd on the vfs.
428 ****************************************************************************/
430 ssize_t vfs_write_data(struct smb_request *req,
438 if (req && req->unread_bytes) {
439 int sockfd = req->xconn->transport.sock;
441 SMB_ASSERT(req->unread_bytes == N);
442 /* VFS_RECVFILE must drain the socket
443 * before returning. */
444 req->unread_bytes = 0;
445 /* Ensure the socket is blocking. */
446 old_flags = fcntl(sockfd, F_GETFL, 0);
447 if (set_blocking(sockfd, true) == -1) {
450 ret = SMB_VFS_RECVFILE(sockfd,
454 if (fcntl(sockfd, F_SETFL, old_flags) == -1) {
461 ret = SMB_VFS_WRITE(fsp, buffer + total, N - total);
470 return (ssize_t)total;
473 ssize_t vfs_pwrite_data(struct smb_request *req,
482 if (req && req->unread_bytes) {
483 int sockfd = req->xconn->transport.sock;
484 SMB_ASSERT(req->unread_bytes == N);
485 /* VFS_RECVFILE must drain the socket
486 * before returning. */
487 req->unread_bytes = 0;
489 * Leave the socket non-blocking and
490 * use SMB_VFS_RECVFILE. If it returns
491 * EAGAIN || EWOULDBLOCK temporarily set
492 * the socket blocking and retry
496 ret = SMB_VFS_RECVFILE(sockfd,
500 if (ret == 0 || (ret == -1 &&
502 errno == EWOULDBLOCK))) {
504 /* Ensure the socket is blocking. */
505 old_flags = fcntl(sockfd, F_GETFL, 0);
506 if (set_blocking(sockfd, true) == -1) {
509 ret = SMB_VFS_RECVFILE(sockfd,
513 if (fcntl(sockfd, F_SETFL, old_flags) == -1) {
520 return (ssize_t)total;
522 /* Any other error case. */
528 return (ssize_t)total;
532 ret = SMB_VFS_PWRITE(fsp, buffer + total, N - total,
542 return (ssize_t)total;
544 /****************************************************************************
545 An allocate file space call using the vfs interface.
546 Allocates space for a file from a filedescriptor.
547 Returns 0 on success, -1 on failure.
548 ****************************************************************************/
550 int vfs_allocate_file_space(files_struct *fsp, uint64_t len)
553 connection_struct *conn = fsp->conn;
554 uint64_t space_avail;
555 uint64_t bsize,dfree,dsize;
559 * Actually try and commit the space on disk....
562 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
563 fsp_str_dbg(fsp), (double)len));
565 if (((off_t)len) < 0) {
566 DEBUG(0,("vfs_allocate_file_space: %s negative len "
567 "requested.\n", fsp_str_dbg(fsp)));
572 status = vfs_stat_fsp(fsp);
573 if (!NT_STATUS_IS_OK(status)) {
577 if (len == (uint64_t)fsp->fsp_name->st.st_ex_size)
580 if (len < (uint64_t)fsp->fsp_name->st.st_ex_size) {
581 /* Shrink - use ftruncate. */
583 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current "
584 "size %.0f\n", fsp_str_dbg(fsp),
585 (double)fsp->fsp_name->st.st_ex_size));
587 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_ALLOC_SHRINK);
589 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
590 if ((ret = SMB_VFS_FTRUNCATE(fsp, (off_t)len)) != -1) {
591 set_filelen_write_cache(fsp, len);
594 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_ALLOC_SHRINK);
599 /* Grow - we need to test if we have enough space. */
601 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_ALLOC_GROW);
603 if (lp_strict_allocate(SNUM(fsp->conn))) {
604 /* See if we have a syscall that will allocate beyond
605 end-of-file without changing EOF. */
606 ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_FL_KEEP_SIZE,
612 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_ALLOC_GROW);
615 /* We changed the allocation size on disk, but not
616 EOF - exactly as required. We're done ! */
620 if (ret == -1 && errno == ENOSPC) {
624 len -= fsp->fsp_name->st.st_ex_size;
625 len /= 1024; /* Len is now number of 1k blocks needed. */
627 get_dfree_info(conn, fsp->fsp_name, &bsize, &dfree, &dsize);
628 if (space_avail == (uint64_t)-1) {
632 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
633 "needed blocks = %.0f, space avail = %.0f\n",
634 fsp_str_dbg(fsp), (double)fsp->fsp_name->st.st_ex_size, (double)len,
635 (double)space_avail));
637 if (len > space_avail) {
645 /****************************************************************************
646 A vfs set_filelen call.
647 set the length of a file from a filedescriptor.
648 Returns 0 on success, -1 on failure.
649 ****************************************************************************/
651 int vfs_set_filelen(files_struct *fsp, off_t len)
655 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
657 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
658 fsp_str_dbg(fsp), (double)len));
659 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
660 if ((ret = SMB_VFS_FTRUNCATE(fsp, len)) != -1) {
661 set_filelen_write_cache(fsp, len);
662 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
663 FILE_NOTIFY_CHANGE_SIZE
664 | FILE_NOTIFY_CHANGE_ATTRIBUTES,
665 fsp->fsp_name->base_name);
668 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
673 /****************************************************************************
674 A slow version of fallocate. Fallback code if SMB_VFS_FALLOCATE
675 fails. Needs to be outside of the default version of SMB_VFS_FALLOCATE
676 as this is also called from the default SMB_VFS_FTRUNCATE code.
677 Always extends the file size.
678 Returns 0 on success, -1 on failure.
679 ****************************************************************************/
681 #define SPARSE_BUF_WRITE_SIZE (32*1024)
683 int vfs_slow_fallocate(files_struct *fsp, off_t offset, off_t len)
689 sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
696 while (total < len) {
697 size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (len - total));
699 pwrite_ret = SMB_VFS_PWRITE(fsp, sparse_buf, curr_write_size, offset + total);
700 if (pwrite_ret == -1) {
701 int saved_errno = errno;
702 DEBUG(10,("vfs_slow_fallocate: SMB_VFS_PWRITE for file "
703 "%s failed with error %s\n",
704 fsp_str_dbg(fsp), strerror(saved_errno)));
714 /****************************************************************************
715 A vfs fill sparse call.
716 Writes zeros from the end of file to len, if len is greater than EOF.
717 Used only by strict_sync.
718 Returns 0 on success, -1 on failure.
719 ****************************************************************************/
721 int vfs_fill_sparse(files_struct *fsp, off_t len)
728 status = vfs_stat_fsp(fsp);
729 if (!NT_STATUS_IS_OK(status)) {
733 if (len <= fsp->fsp_name->st.st_ex_size) {
738 if (S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
743 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
744 "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp),
745 (double)fsp->fsp_name->st.st_ex_size, (double)len,
746 (double)(len - fsp->fsp_name->st.st_ex_size)));
748 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_FILL_SPARSE);
750 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
752 offset = fsp->fsp_name->st.st_ex_size;
753 num_to_write = len - fsp->fsp_name->st.st_ex_size;
755 /* Only do this on non-stream file handles. */
756 if (fsp->base_fsp == NULL) {
757 /* for allocation try fallocate first. This can fail on some
758 * platforms e.g. when the filesystem doesn't support it and no
759 * emulation is being done by the libc (like on AIX with JFS1). In that
760 * case we do our own emulation. fallocate implementations can
761 * return ENOTSUP or EINVAL in cases like that. */
762 ret = SMB_VFS_FALLOCATE(fsp, 0, offset, num_to_write);
763 if (ret == -1 && errno == ENOSPC) {
769 DEBUG(10,("vfs_fill_sparse: SMB_VFS_FALLOCATE failed with "
770 "error %d. Falling back to slow manual allocation\n", ret));
773 ret = vfs_slow_fallocate(fsp, offset, num_to_write);
778 set_filelen_write_cache(fsp, len);
781 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_FILL_SPARSE);
785 /****************************************************************************
786 Transfer some data (n bytes) between two file_struct's.
787 ****************************************************************************/
789 static ssize_t vfs_pread_fn(void *file, void *buf, size_t len, off_t offset)
791 struct files_struct *fsp = (struct files_struct *)file;
793 return SMB_VFS_PREAD(fsp, buf, len, offset);
796 static ssize_t vfs_pwrite_fn(void *file, const void *buf, size_t len, off_t offset)
798 struct files_struct *fsp = (struct files_struct *)file;
800 return SMB_VFS_PWRITE(fsp, buf, len, offset);
803 off_t vfs_transfer_file(files_struct *in, files_struct *out, off_t n)
805 return transfer_file_internal((void *)in, (void *)out, n,
806 vfs_pread_fn, vfs_pwrite_fn);
809 /*******************************************************************
810 A vfs_readdir wrapper which just returns the file name.
811 ********************************************************************/
813 const char *vfs_readdirname(connection_struct *conn, void *p,
814 SMB_STRUCT_STAT *sbuf, char **talloced)
816 struct dirent *ptr= NULL;
824 ptr = SMB_VFS_READDIR(conn, (DIR *)p, sbuf);
836 #ifdef HAVE_BROKEN_READDIR_NAME
837 /* using /usr/ucb/cc is BAD */
841 status = SMB_VFS_TRANSLATE_NAME(conn, dname, vfs_translate_to_windows,
842 talloc_tos(), &translated);
843 if (NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) {
847 *talloced = translated;
848 if (!NT_STATUS_IS_OK(status)) {
854 /*******************************************************************
855 A wrapper for vfs_chdir().
856 ********************************************************************/
858 int vfs_ChDir(connection_struct *conn, const struct smb_filename *smb_fname)
862 struct smb_filename *saved_cwd = NULL;
865 LastDir = SMB_STRDUP("");
868 if (ISDOT(smb_fname->base_name)) {
872 if (*smb_fname->base_name == '/' &&
873 strcsequal(LastDir,smb_fname->base_name)) {
877 if (conn->cwd_fname != NULL) {
879 * Save off where we are in case we need to return
880 * on vfs_GetWd() failure after successful SMB_VFS_CHDIR().
882 saved_cwd = cp_smb_filename(conn, conn->cwd_fname);
883 if (saved_cwd == NULL) {
888 DEBUG(4,("vfs_ChDir to %s\n", smb_fname->base_name));
890 ret = SMB_VFS_CHDIR(conn, smb_fname);
893 TALLOC_FREE(saved_cwd);
899 * Always replace conn->cwd_fname. We
900 * don't know if it's been modified by
901 * VFS modules in the stack.
905 TALLOC_FREE(conn->cwd_fname);
906 conn->cwd_fname = vfs_GetWd(conn, conn);
907 if (conn->cwd_fname == NULL) {
909 * vfs_GetWd() failed.
910 * We must be able to read cwd.
911 * Return to original directory
916 if (saved_cwd == NULL) {
918 * Failed on the very first chdir()+getwd()
919 * for this connection. We can't
922 smb_panic("conn->cwd getwd failed\n");
927 /* Return to the previous $cwd. */
928 ret = SMB_VFS_CHDIR(conn, saved_cwd);
930 smb_panic("conn->cwd getwd failed\n");
934 /* Restore original conn->cwd_fname. */
935 conn->cwd_fname = saved_cwd;
937 /* And fail the chdir(). */
941 /* vfs_GetWd() succeeded. */
942 /* Replace global cache. */
944 LastDir = SMB_STRDUP(smb_fname->base_name);
946 DEBUG(4,("vfs_ChDir got %s\n", conn->cwd_fname->base_name));
948 TALLOC_FREE(saved_cwd);
949 if (saved_errno != 0) {
955 /*******************************************************************
956 Return the absolute current directory path - given a UNIX pathname.
957 Note that this path is returned in DOS format, not UNIX
958 format. Note this can be called with conn == NULL.
959 ********************************************************************/
961 struct smb_filename *vfs_GetWd(TALLOC_CTX *ctx, connection_struct *conn)
963 struct smb_filename *current_dir_fname = NULL;
965 struct smb_filename *smb_fname_dot = NULL;
966 struct smb_filename *smb_fname_full = NULL;
967 struct smb_filename *result = NULL;
969 if (!lp_getwd_cache()) {
973 smb_fname_dot = synthetic_smb_fname(ctx, ".", NULL, NULL, 0);
974 if (smb_fname_dot == NULL) {
979 if (SMB_VFS_STAT(conn, smb_fname_dot) == -1) {
981 * Known to fail for root: the directory may be NFS-mounted
982 * and exported with root_squash (so has no root access).
984 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
985 "(NFS problem ?)\n", strerror(errno) ));
989 key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
991 smb_fname_full = (struct smb_filename *)memcache_lookup_talloc(
994 data_blob_const(&key, sizeof(key)));
996 if (smb_fname_full == NULL) {
1000 if ((SMB_VFS_STAT(conn, smb_fname_full) == 0) &&
1001 (smb_fname_dot->st.st_ex_dev == smb_fname_full->st.st_ex_dev) &&
1002 (smb_fname_dot->st.st_ex_ino == smb_fname_full->st.st_ex_ino) &&
1003 (S_ISDIR(smb_fname_dot->st.st_ex_mode))) {
1006 * Note: smb_fname_full is owned by smbd_memcache()
1007 * so we must make a copy to return.
1009 result = cp_smb_filename(ctx, smb_fname_full);
1010 if (result == NULL) {
1019 * We don't have the information to hand so rely on traditional
1020 * methods. The very slow getcwd, which spawns a process on some
1021 * systems, or the not quite so bad getwd.
1024 current_dir_fname = SMB_VFS_GETWD(conn, ctx);
1025 if (current_dir_fname == NULL) {
1026 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
1031 if (lp_getwd_cache() && VALID_STAT(smb_fname_dot->st)) {
1032 key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
1035 * smbd_memcache() will own current_dir_fname after the
1036 * memcache_add_talloc call, so we must make
1037 * a copy on ctx to return.
1039 result = cp_smb_filename(ctx, current_dir_fname);
1040 if (result == NULL) {
1045 * Ensure the memory going into the cache
1046 * doesn't have a destructor so it can be
1049 talloc_set_destructor(current_dir_fname, NULL);
1051 memcache_add_talloc(smbd_memcache(),
1053 data_blob_const(&key, sizeof(key)),
1054 ¤t_dir_fname);
1055 /* current_dir_fname is now == NULL here. */
1057 /* current_dir_fname is already allocated on ctx. */
1058 result = current_dir_fname;
1062 TALLOC_FREE(smb_fname_dot);
1064 * Don't free current_dir_fname here. It's either been moved
1065 * to the memcache or is being returned in result.
1070 /*******************************************************************
1071 Reduce a file name, removing .. elements and checking that
1072 it is below dir in the heirachy. This uses realpath.
1073 This function must run as root, and will return names
1074 and valid stat structs that can be checked on open.
1075 ********************************************************************/
1077 NTSTATUS check_reduced_name_with_privilege(connection_struct *conn,
1078 const struct smb_filename *smb_fname,
1079 struct smb_request *smbreq)
1082 TALLOC_CTX *ctx = talloc_tos();
1083 const char *conn_rootdir;
1085 char *dir_name = NULL;
1086 char *resolved_name = NULL;
1087 const char *last_component = NULL;
1088 struct smb_filename *resolved_fname = NULL;
1089 struct smb_filename *saved_dir_fname = NULL;
1090 struct smb_filename *smb_fname_cwd = NULL;
1091 struct privilege_paths *priv_paths = NULL;
1094 DEBUG(3,("check_reduced_name_with_privilege [%s] [%s]\n",
1095 smb_fname->base_name,
1096 conn->connectpath));
1099 priv_paths = talloc_zero(smbreq, struct privilege_paths);
1101 status = NT_STATUS_NO_MEMORY;
1105 if (!parent_dirname(ctx, smb_fname->base_name,
1106 &dir_name, &last_component)) {
1107 status = NT_STATUS_NO_MEMORY;
1111 priv_paths->parent_name.base_name = talloc_strdup(priv_paths, dir_name);
1112 priv_paths->file_name.base_name = talloc_strdup(priv_paths, last_component);
1114 if (priv_paths->parent_name.base_name == NULL ||
1115 priv_paths->file_name.base_name == NULL) {
1116 status = NT_STATUS_NO_MEMORY;
1120 if (SMB_VFS_STAT(conn, &priv_paths->parent_name) != 0) {
1121 status = map_nt_error_from_unix(errno);
1124 /* Remember where we were. */
1125 saved_dir_fname = vfs_GetWd(ctx, conn);
1126 if (!saved_dir_fname) {
1127 status = map_nt_error_from_unix(errno);
1131 if (vfs_ChDir(conn, &priv_paths->parent_name) == -1) {
1132 status = map_nt_error_from_unix(errno);
1136 smb_fname_cwd = synthetic_smb_fname(talloc_tos(), ".", NULL, NULL, 0);
1137 if (smb_fname_cwd == NULL) {
1138 status = NT_STATUS_NO_MEMORY;
1142 /* Get the absolute path of the parent directory. */
1143 resolved_fname = SMB_VFS_REALPATH(conn, ctx, smb_fname_cwd);
1144 if (resolved_fname == NULL) {
1145 status = map_nt_error_from_unix(errno);
1148 resolved_name = resolved_fname->base_name;
1150 if (*resolved_name != '/') {
1151 DEBUG(0,("check_reduced_name_with_privilege: realpath "
1152 "doesn't return absolute paths !\n"));
1153 status = NT_STATUS_OBJECT_NAME_INVALID;
1157 DEBUG(10,("check_reduced_name_with_privilege: realpath [%s] -> [%s]\n",
1158 priv_paths->parent_name.base_name,
1161 /* Now check the stat value is the same. */
1162 if (SMB_VFS_LSTAT(conn, smb_fname_cwd) != 0) {
1163 status = map_nt_error_from_unix(errno);
1167 /* Ensure we're pointing at the same place. */
1168 if (!check_same_stat(&smb_fname_cwd->st, &priv_paths->parent_name.st)) {
1169 DEBUG(0,("check_reduced_name_with_privilege: "
1170 "device/inode/uid/gid on directory %s changed. "
1171 "Denying access !\n",
1172 priv_paths->parent_name.base_name));
1173 status = NT_STATUS_ACCESS_DENIED;
1177 /* Ensure we're below the connect path. */
1179 conn_rootdir = SMB_VFS_CONNECTPATH(conn, smb_fname);
1180 if (conn_rootdir == NULL) {
1181 DEBUG(2, ("check_reduced_name_with_privilege: Could not get "
1183 status = NT_STATUS_ACCESS_DENIED;
1187 rootdir_len = strlen(conn_rootdir);
1190 * In the case of rootdir_len == 1, we know that conn_rootdir is
1191 * "/", and we also know that resolved_name starts with a slash.
1192 * So, in this corner case, resolved_name is automatically a
1193 * sub-directory of the conn_rootdir. Thus we can skip the string
1194 * comparison and the next character checks (which are even
1195 * wrong in this case).
1197 if (rootdir_len != 1) {
1200 matched = (strncmp(conn_rootdir, resolved_name,
1203 if (!matched || (resolved_name[rootdir_len] != '/' &&
1204 resolved_name[rootdir_len] != '\0')) {
1205 DEBUG(2, ("check_reduced_name_with_privilege: Bad "
1206 "access attempt: %s is a symlink outside the "
1209 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir));
1210 DEBUGADD(2, ("resolved_name=%s\n", resolved_name));
1211 status = NT_STATUS_ACCESS_DENIED;
1216 /* Now ensure that the last component either doesn't
1217 exist, or is *NOT* a symlink. */
1219 ret = SMB_VFS_LSTAT(conn, &priv_paths->file_name);
1221 /* Errno must be ENOENT for this be ok. */
1222 if (errno != ENOENT) {
1223 status = map_nt_error_from_unix(errno);
1224 DEBUG(2, ("check_reduced_name_with_privilege: "
1225 "LSTAT on %s failed with %s\n",
1226 priv_paths->file_name.base_name,
1227 nt_errstr(status)));
1232 if (VALID_STAT(priv_paths->file_name.st) &&
1233 S_ISLNK(priv_paths->file_name.st.st_ex_mode)) {
1234 DEBUG(2, ("check_reduced_name_with_privilege: "
1235 "Last component %s is a symlink. Denying"
1237 priv_paths->file_name.base_name));
1238 status = NT_STATUS_ACCESS_DENIED;
1242 smbreq->priv_paths = priv_paths;
1243 status = NT_STATUS_OK;
1247 if (saved_dir_fname != NULL) {
1248 vfs_ChDir(conn, saved_dir_fname);
1249 TALLOC_FREE(saved_dir_fname);
1251 TALLOC_FREE(resolved_fname);
1252 if (!NT_STATUS_IS_OK(status)) {
1253 TALLOC_FREE(priv_paths);
1255 TALLOC_FREE(dir_name);
1259 /*******************************************************************
1260 Reduce a file name, removing .. elements and checking that
1261 it is below dir in the heirachy. This uses realpath.
1263 If cwd_name == NULL then fname is a client given path relative
1264 to the root path of the share.
1266 If cwd_name != NULL then fname is a client given path relative
1267 to cwd_name. cwd_name is relative to the root path of the share.
1268 ********************************************************************/
1270 NTSTATUS check_reduced_name(connection_struct *conn,
1271 const struct smb_filename *cwd_fname,
1272 const struct smb_filename *smb_fname)
1274 TALLOC_CTX *ctx = talloc_tos();
1275 const char *cwd_name = cwd_fname ? cwd_fname->base_name : NULL;
1276 const char *fname = smb_fname->base_name;
1277 struct smb_filename *resolved_fname;
1278 char *resolved_name = NULL;
1279 char *new_fname = NULL;
1280 bool allow_symlinks = true;
1281 bool allow_widelinks = false;
1283 DBG_DEBUG("check_reduced_name [%s] [%s]\n", fname, conn->connectpath);
1285 resolved_fname = SMB_VFS_REALPATH(conn, ctx, smb_fname);
1287 if (resolved_fname == NULL) {
1290 DEBUG(3,("check_reduced_name: Component not a "
1291 "directory in getting realpath for "
1293 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1296 char *dir_name = NULL;
1297 struct smb_filename dir_fname = {0};
1298 const char *last_component = NULL;
1300 /* Last component didn't exist.
1301 Remove it and try and canonicalise
1302 the directory name. */
1303 if (!parent_dirname(ctx, fname,
1306 return NT_STATUS_NO_MEMORY;
1309 dir_fname = (struct smb_filename)
1310 { .base_name = dir_name };
1311 resolved_fname = SMB_VFS_REALPATH(conn,
1314 if (resolved_fname == NULL) {
1315 NTSTATUS status = map_nt_error_from_unix(errno);
1317 if (errno == ENOENT || errno == ENOTDIR) {
1318 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
1321 DEBUG(3,("check_reduce_name: "
1322 "couldn't get realpath for "
1325 nt_errstr(status)));
1328 resolved_name = talloc_asprintf(ctx,
1330 resolved_fname->base_name,
1332 if (resolved_name == NULL) {
1333 return NT_STATUS_NO_MEMORY;
1338 DEBUG(3,("check_reduced_name: couldn't get "
1339 "realpath for %s\n", fname));
1340 return map_nt_error_from_unix(errno);
1343 resolved_name = resolved_fname->base_name;
1346 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname,
1349 if (*resolved_name != '/') {
1350 DEBUG(0,("check_reduced_name: realpath doesn't return "
1351 "absolute paths !\n"));
1352 TALLOC_FREE(resolved_fname);
1353 return NT_STATUS_OBJECT_NAME_INVALID;
1356 allow_widelinks = lp_widelinks(SNUM(conn));
1357 allow_symlinks = lp_follow_symlinks(SNUM(conn));
1359 /* Common widelinks and symlinks checks. */
1360 if (!allow_widelinks || !allow_symlinks) {
1361 const char *conn_rootdir;
1364 conn_rootdir = SMB_VFS_CONNECTPATH(conn, smb_fname);
1365 if (conn_rootdir == NULL) {
1366 DEBUG(2, ("check_reduced_name: Could not get "
1368 TALLOC_FREE(resolved_fname);
1369 return NT_STATUS_ACCESS_DENIED;
1372 rootdir_len = strlen(conn_rootdir);
1375 * In the case of rootdir_len == 1, we know that
1376 * conn_rootdir is "/", and we also know that
1377 * resolved_name starts with a slash. So, in this
1378 * corner case, resolved_name is automatically a
1379 * sub-directory of the conn_rootdir. Thus we can skip
1380 * the string comparison and the next character checks
1381 * (which are even wrong in this case).
1383 if (rootdir_len != 1) {
1386 matched = (strncmp(conn_rootdir, resolved_name,
1388 if (!matched || (resolved_name[rootdir_len] != '/' &&
1389 resolved_name[rootdir_len] != '\0')) {
1390 DEBUG(2, ("check_reduced_name: Bad access "
1391 "attempt: %s is a symlink outside the "
1392 "share path\n", fname));
1393 DEBUGADD(2, ("conn_rootdir =%s\n",
1395 DEBUGADD(2, ("resolved_name=%s\n",
1397 TALLOC_FREE(resolved_fname);
1398 return NT_STATUS_ACCESS_DENIED;
1402 /* Extra checks if all symlinks are disallowed. */
1403 if (!allow_symlinks) {
1404 /* fname can't have changed in resolved_path. */
1405 const char *p = &resolved_name[rootdir_len];
1408 * UNIX filesystem semantics, names consisting
1409 * only of "." or ".." CANNOT be symlinks.
1411 if (ISDOT(fname) || ISDOTDOT(fname)) {
1416 DEBUG(2, ("check_reduced_name: logic error (%c) "
1417 "in resolved_name: %s\n",
1420 TALLOC_FREE(resolved_fname);
1421 return NT_STATUS_ACCESS_DENIED;
1427 * If cwd_name is present and not ".",
1428 * then fname is relative to that, not
1429 * the root of the share. Make sure the
1430 * path we check is the one the client
1431 * sent (cwd_name+fname).
1433 if (cwd_name != NULL && !ISDOT(cwd_name)) {
1434 new_fname = talloc_asprintf(ctx,
1438 if (new_fname == NULL) {
1439 TALLOC_FREE(resolved_fname);
1440 return NT_STATUS_NO_MEMORY;
1445 if (strcmp(fname, p)!=0) {
1446 DEBUG(2, ("check_reduced_name: Bad access "
1447 "attempt: %s is a symlink to %s\n",
1449 TALLOC_FREE(resolved_fname);
1450 TALLOC_FREE(new_fname);
1451 return NT_STATUS_ACCESS_DENIED;
1458 DBG_INFO("%s reduced to %s\n", fname, resolved_name);
1459 TALLOC_FREE(resolved_fname);
1460 TALLOC_FREE(new_fname);
1461 return NT_STATUS_OK;
1465 * XXX: This is temporary and there should be no callers of this once
1466 * smb_filename is plumbed through all path based operations.
1468 * Called when we know stream name parsing has already been done.
1470 int vfs_stat_smb_basename(struct connection_struct *conn,
1471 const struct smb_filename *smb_fname_in,
1472 SMB_STRUCT_STAT *psbuf)
1474 struct smb_filename smb_fname = {
1475 .base_name = discard_const_p(char, smb_fname_in->base_name),
1476 .flags = smb_fname_in->flags
1480 if (smb_fname.flags & SMB_FILENAME_POSIX_PATH) {
1481 ret = SMB_VFS_LSTAT(conn, &smb_fname);
1483 ret = SMB_VFS_STAT(conn, &smb_fname);
1487 *psbuf = smb_fname.st;
1493 * Ensure LSTAT is called for POSIX paths.
1496 NTSTATUS vfs_stat_fsp(files_struct *fsp)
1500 if(fsp->fh->fd == -1) {
1501 if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
1502 ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
1504 ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
1507 return map_nt_error_from_unix(errno);
1510 if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
1511 return map_nt_error_from_unix(errno);
1514 return NT_STATUS_OK;
1518 * Initialize num_streams and streams, then call VFS op streaminfo
1520 NTSTATUS vfs_streaminfo(connection_struct *conn,
1521 struct files_struct *fsp,
1522 const struct smb_filename *smb_fname,
1523 TALLOC_CTX *mem_ctx,
1524 unsigned int *num_streams,
1525 struct stream_struct **streams)
1529 return SMB_VFS_STREAMINFO(conn,
1538 generate a file_id from a stat structure
1540 struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_STAT *sbuf)
1542 return SMB_VFS_FILE_ID_CREATE(conn, sbuf);
1545 int smb_vfs_call_connect(struct vfs_handle_struct *handle,
1546 const char *service, const char *user)
1549 return handle->fns->connect_fn(handle, service, user);
1552 void smb_vfs_call_disconnect(struct vfs_handle_struct *handle)
1554 VFS_FIND(disconnect);
1555 handle->fns->disconnect_fn(handle);
1558 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle,
1559 const struct smb_filename *smb_fname,
1564 VFS_FIND(disk_free);
1565 return handle->fns->disk_free_fn(handle, smb_fname,
1566 bsize, dfree, dsize);
1569 int smb_vfs_call_get_quota(struct vfs_handle_struct *handle,
1570 const struct smb_filename *smb_fname,
1571 enum SMB_QUOTA_TYPE qtype,
1575 VFS_FIND(get_quota);
1576 return handle->fns->get_quota_fn(handle, smb_fname, qtype, id, qt);
1579 int smb_vfs_call_set_quota(struct vfs_handle_struct *handle,
1580 enum SMB_QUOTA_TYPE qtype, unid_t id,
1583 VFS_FIND(set_quota);
1584 return handle->fns->set_quota_fn(handle, qtype, id, qt);
1587 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle,
1588 struct files_struct *fsp,
1589 struct shadow_copy_data *shadow_copy_data,
1592 VFS_FIND(get_shadow_copy_data);
1593 return handle->fns->get_shadow_copy_data_fn(handle, fsp,
1597 int smb_vfs_call_statvfs(struct vfs_handle_struct *handle,
1598 const struct smb_filename *smb_fname,
1599 struct vfs_statvfs_struct *statbuf)
1602 return handle->fns->statvfs_fn(handle, smb_fname, statbuf);
1605 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle,
1606 enum timestamp_set_resolution *p_ts_res)
1608 VFS_FIND(fs_capabilities);
1609 return handle->fns->fs_capabilities_fn(handle, p_ts_res);
1612 NTSTATUS smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct *handle,
1613 struct dfs_GetDFSReferral *r)
1615 VFS_FIND(get_dfs_referrals);
1616 return handle->fns->get_dfs_referrals_fn(handle, r);
1619 DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle,
1620 const struct smb_filename *smb_fname,
1622 uint32_t attributes)
1625 return handle->fns->opendir_fn(handle, smb_fname, mask, attributes);
1628 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle,
1629 struct files_struct *fsp,
1631 uint32_t attributes)
1633 VFS_FIND(fdopendir);
1634 return handle->fns->fdopendir_fn(handle, fsp, mask, attributes);
1637 struct dirent *smb_vfs_call_readdir(struct vfs_handle_struct *handle,
1639 SMB_STRUCT_STAT *sbuf)
1642 return handle->fns->readdir_fn(handle, dirp, sbuf);
1645 void smb_vfs_call_seekdir(struct vfs_handle_struct *handle,
1646 DIR *dirp, long offset)
1649 handle->fns->seekdir_fn(handle, dirp, offset);
1652 long smb_vfs_call_telldir(struct vfs_handle_struct *handle,
1656 return handle->fns->telldir_fn(handle, dirp);
1659 void smb_vfs_call_rewind_dir(struct vfs_handle_struct *handle,
1662 VFS_FIND(rewind_dir);
1663 handle->fns->rewind_dir_fn(handle, dirp);
1666 int smb_vfs_call_mkdir(struct vfs_handle_struct *handle,
1667 const struct smb_filename *smb_fname,
1671 return handle->fns->mkdir_fn(handle, smb_fname, mode);
1674 int smb_vfs_call_rmdir(struct vfs_handle_struct *handle,
1675 const struct smb_filename *smb_fname)
1678 return handle->fns->rmdir_fn(handle, smb_fname);
1681 int smb_vfs_call_closedir(struct vfs_handle_struct *handle,
1685 return handle->fns->closedir_fn(handle, dir);
1688 int smb_vfs_call_open(struct vfs_handle_struct *handle,
1689 struct smb_filename *smb_fname, struct files_struct *fsp,
1690 int flags, mode_t mode)
1693 return handle->fns->open_fn(handle, smb_fname, fsp, flags, mode);
1696 NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle,
1697 struct smb_request *req,
1698 uint16_t root_dir_fid,
1699 struct smb_filename *smb_fname,
1700 uint32_t access_mask,
1701 uint32_t share_access,
1702 uint32_t create_disposition,
1703 uint32_t create_options,
1704 uint32_t file_attributes,
1705 uint32_t oplock_request,
1706 struct smb2_lease *lease,
1707 uint64_t allocation_size,
1708 uint32_t private_flags,
1709 struct security_descriptor *sd,
1710 struct ea_list *ea_list,
1711 files_struct **result,
1713 const struct smb2_create_blobs *in_context_blobs,
1714 struct smb2_create_blobs *out_context_blobs)
1716 VFS_FIND(create_file);
1717 return handle->fns->create_file_fn(
1718 handle, req, root_dir_fid, smb_fname, access_mask,
1719 share_access, create_disposition, create_options,
1720 file_attributes, oplock_request, lease, allocation_size,
1721 private_flags, sd, ea_list,
1722 result, pinfo, in_context_blobs, out_context_blobs);
1725 int smb_vfs_call_close(struct vfs_handle_struct *handle,
1726 struct files_struct *fsp)
1729 return handle->fns->close_fn(handle, fsp);
1732 ssize_t smb_vfs_call_read(struct vfs_handle_struct *handle,
1733 struct files_struct *fsp, void *data, size_t n)
1736 return handle->fns->read_fn(handle, fsp, data, n);
1739 ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
1740 struct files_struct *fsp, void *data, size_t n,
1744 return handle->fns->pread_fn(handle, fsp, data, n, offset);
1747 struct smb_vfs_call_pread_state {
1748 ssize_t (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1750 struct vfs_aio_state vfs_aio_state;
1753 static void smb_vfs_call_pread_done(struct tevent_req *subreq);
1755 struct tevent_req *smb_vfs_call_pread_send(struct vfs_handle_struct *handle,
1756 TALLOC_CTX *mem_ctx,
1757 struct tevent_context *ev,
1758 struct files_struct *fsp,
1760 size_t n, off_t offset)
1762 struct tevent_req *req, *subreq;
1763 struct smb_vfs_call_pread_state *state;
1765 req = tevent_req_create(mem_ctx, &state,
1766 struct smb_vfs_call_pread_state);
1770 VFS_FIND(pread_send);
1771 state->recv_fn = handle->fns->pread_recv_fn;
1773 subreq = handle->fns->pread_send_fn(handle, state, ev, fsp, data, n,
1775 if (tevent_req_nomem(subreq, req)) {
1776 return tevent_req_post(req, ev);
1778 tevent_req_set_callback(subreq, smb_vfs_call_pread_done, req);
1782 static void smb_vfs_call_pread_done(struct tevent_req *subreq)
1784 struct tevent_req *req = tevent_req_callback_data(
1785 subreq, struct tevent_req);
1786 struct smb_vfs_call_pread_state *state = tevent_req_data(
1787 req, struct smb_vfs_call_pread_state);
1789 state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1790 TALLOC_FREE(subreq);
1791 if (state->retval == -1) {
1792 tevent_req_error(req, state->vfs_aio_state.error);
1795 tevent_req_done(req);
1798 ssize_t SMB_VFS_PREAD_RECV(struct tevent_req *req,
1799 struct vfs_aio_state *vfs_aio_state)
1801 struct smb_vfs_call_pread_state *state = tevent_req_data(
1802 req, struct smb_vfs_call_pread_state);
1804 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1807 *vfs_aio_state = state->vfs_aio_state;
1808 return state->retval;
1811 ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle,
1812 struct files_struct *fsp, const void *data,
1816 return handle->fns->write_fn(handle, fsp, data, n);
1819 ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
1820 struct files_struct *fsp, const void *data,
1821 size_t n, off_t offset)
1824 return handle->fns->pwrite_fn(handle, fsp, data, n, offset);
1827 struct smb_vfs_call_pwrite_state {
1828 ssize_t (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1830 struct vfs_aio_state vfs_aio_state;
1833 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq);
1835 struct tevent_req *smb_vfs_call_pwrite_send(struct vfs_handle_struct *handle,
1836 TALLOC_CTX *mem_ctx,
1837 struct tevent_context *ev,
1838 struct files_struct *fsp,
1840 size_t n, off_t offset)
1842 struct tevent_req *req, *subreq;
1843 struct smb_vfs_call_pwrite_state *state;
1845 req = tevent_req_create(mem_ctx, &state,
1846 struct smb_vfs_call_pwrite_state);
1850 VFS_FIND(pwrite_send);
1851 state->recv_fn = handle->fns->pwrite_recv_fn;
1853 subreq = handle->fns->pwrite_send_fn(handle, state, ev, fsp, data, n,
1855 if (tevent_req_nomem(subreq, req)) {
1856 return tevent_req_post(req, ev);
1858 tevent_req_set_callback(subreq, smb_vfs_call_pwrite_done, req);
1862 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq)
1864 struct tevent_req *req = tevent_req_callback_data(
1865 subreq, struct tevent_req);
1866 struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1867 req, struct smb_vfs_call_pwrite_state);
1869 state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1870 TALLOC_FREE(subreq);
1871 if (state->retval == -1) {
1872 tevent_req_error(req, state->vfs_aio_state.error);
1875 tevent_req_done(req);
1878 ssize_t SMB_VFS_PWRITE_RECV(struct tevent_req *req,
1879 struct vfs_aio_state *vfs_aio_state)
1881 struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1882 req, struct smb_vfs_call_pwrite_state);
1884 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1887 *vfs_aio_state = state->vfs_aio_state;
1888 return state->retval;
1891 off_t smb_vfs_call_lseek(struct vfs_handle_struct *handle,
1892 struct files_struct *fsp, off_t offset,
1896 return handle->fns->lseek_fn(handle, fsp, offset, whence);
1899 ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
1900 files_struct *fromfsp, const DATA_BLOB *header,
1901 off_t offset, size_t count)
1904 return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset,
1908 ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
1909 files_struct *tofsp, off_t offset,
1913 return handle->fns->recvfile_fn(handle, fromfd, tofsp, offset, count);
1916 int smb_vfs_call_rename(struct vfs_handle_struct *handle,
1917 const struct smb_filename *smb_fname_src,
1918 const struct smb_filename *smb_fname_dst)
1921 return handle->fns->rename_fn(handle, smb_fname_src, smb_fname_dst);
1924 struct smb_vfs_call_fsync_state {
1925 int (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1927 struct vfs_aio_state vfs_aio_state;
1930 static void smb_vfs_call_fsync_done(struct tevent_req *subreq);
1932 struct tevent_req *smb_vfs_call_fsync_send(struct vfs_handle_struct *handle,
1933 TALLOC_CTX *mem_ctx,
1934 struct tevent_context *ev,
1935 struct files_struct *fsp)
1937 struct tevent_req *req, *subreq;
1938 struct smb_vfs_call_fsync_state *state;
1940 req = tevent_req_create(mem_ctx, &state,
1941 struct smb_vfs_call_fsync_state);
1945 VFS_FIND(fsync_send);
1946 state->recv_fn = handle->fns->fsync_recv_fn;
1948 subreq = handle->fns->fsync_send_fn(handle, state, ev, fsp);
1949 if (tevent_req_nomem(subreq, req)) {
1950 return tevent_req_post(req, ev);
1952 tevent_req_set_callback(subreq, smb_vfs_call_fsync_done, req);
1956 static void smb_vfs_call_fsync_done(struct tevent_req *subreq)
1958 struct tevent_req *req = tevent_req_callback_data(
1959 subreq, struct tevent_req);
1960 struct smb_vfs_call_fsync_state *state = tevent_req_data(
1961 req, struct smb_vfs_call_fsync_state);
1963 state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1964 TALLOC_FREE(subreq);
1965 if (state->retval == -1) {
1966 tevent_req_error(req, state->vfs_aio_state.error);
1969 tevent_req_done(req);
1972 int SMB_VFS_FSYNC_RECV(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state)
1974 struct smb_vfs_call_fsync_state *state = tevent_req_data(
1975 req, struct smb_vfs_call_fsync_state);
1977 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1980 *vfs_aio_state = state->vfs_aio_state;
1981 return state->retval;
1985 * Synchronous version of fsync, built from backend
1986 * async VFS primitives. Uses a temporary sub-event
1987 * context (NOT NESTED).
1990 int smb_vfs_fsync_sync(files_struct *fsp)
1992 TALLOC_CTX *frame = talloc_stackframe();
1993 struct tevent_req *req = NULL;
1994 struct vfs_aio_state aio_state = { 0 };
1997 struct tevent_context *ev = samba_tevent_context_init(frame);
2003 req = SMB_VFS_FSYNC_SEND(talloc_tos(), ev, fsp);
2008 ok = tevent_req_poll(req, ev);
2013 ret = SMB_VFS_FSYNC_RECV(req, &aio_state);
2018 if (aio_state.error != 0) {
2019 errno = aio_state.error;
2024 int smb_vfs_call_stat(struct vfs_handle_struct *handle,
2025 struct smb_filename *smb_fname)
2028 return handle->fns->stat_fn(handle, smb_fname);
2031 int smb_vfs_call_fstat(struct vfs_handle_struct *handle,
2032 struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
2035 return handle->fns->fstat_fn(handle, fsp, sbuf);
2038 int smb_vfs_call_lstat(struct vfs_handle_struct *handle,
2039 struct smb_filename *smb_filename)
2042 return handle->fns->lstat_fn(handle, smb_filename);
2045 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle,
2046 struct files_struct *fsp,
2047 const SMB_STRUCT_STAT *sbuf)
2049 VFS_FIND(get_alloc_size);
2050 return handle->fns->get_alloc_size_fn(handle, fsp, sbuf);
2053 int smb_vfs_call_unlink(struct vfs_handle_struct *handle,
2054 const struct smb_filename *smb_fname)
2057 return handle->fns->unlink_fn(handle, smb_fname);
2060 int smb_vfs_call_chmod(struct vfs_handle_struct *handle,
2061 const struct smb_filename *smb_fname,
2065 return handle->fns->chmod_fn(handle, smb_fname, mode);
2068 int smb_vfs_call_fchmod(struct vfs_handle_struct *handle,
2069 struct files_struct *fsp, mode_t mode)
2072 return handle->fns->fchmod_fn(handle, fsp, mode);
2075 int smb_vfs_call_chown(struct vfs_handle_struct *handle,
2076 const struct smb_filename *smb_fname,
2081 return handle->fns->chown_fn(handle, smb_fname, uid, gid);
2084 int smb_vfs_call_fchown(struct vfs_handle_struct *handle,
2085 struct files_struct *fsp, uid_t uid, gid_t gid)
2088 return handle->fns->fchown_fn(handle, fsp, uid, gid);
2091 int smb_vfs_call_lchown(struct vfs_handle_struct *handle,
2092 const struct smb_filename *smb_fname,
2097 return handle->fns->lchown_fn(handle, smb_fname, uid, gid);
2100 NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid)
2103 bool as_root = false;
2106 if (fsp->fh->fd != -1) {
2108 ret = SMB_VFS_FCHOWN(fsp, uid, gid);
2110 return NT_STATUS_OK;
2112 if (ret == -1 && errno != ENOSYS) {
2113 return map_nt_error_from_unix(errno);
2117 as_root = (geteuid() == 0);
2121 * We are being asked to chown as root. Make
2122 * sure we chdir() into the path to pin it,
2123 * and always act using lchown to ensure we
2124 * don't deref any symbolic links.
2126 char *parent_dir = NULL;
2127 const char *final_component = NULL;
2128 struct smb_filename *local_smb_fname = NULL;
2129 struct smb_filename parent_dir_fname = {0};
2130 struct smb_filename *saved_dir_fname = NULL;
2132 saved_dir_fname = vfs_GetWd(talloc_tos(),fsp->conn);
2133 if (!saved_dir_fname) {
2134 status = map_nt_error_from_unix(errno);
2135 DEBUG(0,("vfs_chown_fsp: failed to get "
2136 "current working directory. Error was %s\n",
2141 if (!parent_dirname(talloc_tos(),
2142 fsp->fsp_name->base_name,
2144 &final_component)) {
2145 return NT_STATUS_NO_MEMORY;
2148 parent_dir_fname = (struct smb_filename) {
2149 .base_name = parent_dir,
2150 .flags = fsp->fsp_name->flags
2153 /* cd into the parent dir to pin it. */
2154 ret = vfs_ChDir(fsp->conn, &parent_dir_fname);
2156 return map_nt_error_from_unix(errno);
2159 local_smb_fname = synthetic_smb_fname(talloc_tos(),
2163 fsp->fsp_name->flags);
2164 if (local_smb_fname == NULL) {
2165 status = NT_STATUS_NO_MEMORY;
2169 /* Must use lstat here. */
2170 ret = SMB_VFS_LSTAT(fsp->conn, local_smb_fname);
2172 status = map_nt_error_from_unix(errno);
2176 /* Ensure it matches the fsp stat. */
2177 if (!check_same_stat(&local_smb_fname->st,
2178 &fsp->fsp_name->st)) {
2179 status = NT_STATUS_ACCESS_DENIED;
2183 ret = SMB_VFS_LCHOWN(fsp->conn,
2188 status = NT_STATUS_OK;
2190 status = map_nt_error_from_unix(errno);
2195 vfs_ChDir(fsp->conn, saved_dir_fname);
2196 TALLOC_FREE(local_smb_fname);
2197 TALLOC_FREE(saved_dir_fname);
2198 TALLOC_FREE(parent_dir);
2203 if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
2204 ret = SMB_VFS_LCHOWN(fsp->conn,
2208 ret = SMB_VFS_CHOWN(fsp->conn,
2214 status = NT_STATUS_OK;
2216 status = map_nt_error_from_unix(errno);
2221 int smb_vfs_call_chdir(struct vfs_handle_struct *handle,
2222 const struct smb_filename *smb_fname)
2225 return handle->fns->chdir_fn(handle, smb_fname);
2228 struct smb_filename *smb_vfs_call_getwd(struct vfs_handle_struct *handle,
2232 return handle->fns->getwd_fn(handle, ctx);
2235 int smb_vfs_call_ntimes(struct vfs_handle_struct *handle,
2236 const struct smb_filename *smb_fname,
2237 struct smb_file_time *ft)
2240 return handle->fns->ntimes_fn(handle, smb_fname, ft);
2243 int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
2244 struct files_struct *fsp, off_t offset)
2246 VFS_FIND(ftruncate);
2247 return handle->fns->ftruncate_fn(handle, fsp, offset);
2250 int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
2251 struct files_struct *fsp,
2256 VFS_FIND(fallocate);
2257 return handle->fns->fallocate_fn(handle, fsp, mode, offset, len);
2260 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
2261 struct files_struct *fsp, uint32_t share_mode,
2262 uint32_t access_mask)
2264 VFS_FIND(kernel_flock);
2265 return handle->fns->kernel_flock_fn(handle, fsp, share_mode,
2269 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
2270 struct files_struct *fsp, int leasetype)
2272 VFS_FIND(linux_setlease);
2273 return handle->fns->linux_setlease_fn(handle, fsp, leasetype);
2276 int smb_vfs_call_symlink(struct vfs_handle_struct *handle,
2277 const char *link_target,
2278 const struct smb_filename *new_smb_fname)
2281 return handle->fns->symlink_fn(handle, link_target, new_smb_fname);
2284 int smb_vfs_call_readlink(struct vfs_handle_struct *handle,
2285 const struct smb_filename *smb_fname,
2290 return handle->fns->readlink_fn(handle, smb_fname, buf, bufsiz);
2293 int smb_vfs_call_link(struct vfs_handle_struct *handle,
2294 const struct smb_filename *old_smb_fname,
2295 const struct smb_filename *new_smb_fname)
2298 return handle->fns->link_fn(handle, old_smb_fname, new_smb_fname);
2301 int smb_vfs_call_mknod(struct vfs_handle_struct *handle,
2302 const struct smb_filename *smb_fname,
2307 return handle->fns->mknod_fn(handle, smb_fname, mode, dev);
2310 struct smb_filename *smb_vfs_call_realpath(struct vfs_handle_struct *handle,
2312 const struct smb_filename *smb_fname)
2315 return handle->fns->realpath_fn(handle, ctx, smb_fname);
2318 int smb_vfs_call_chflags(struct vfs_handle_struct *handle,
2319 const struct smb_filename *smb_fname,
2323 return handle->fns->chflags_fn(handle, smb_fname, flags);
2326 struct file_id smb_vfs_call_file_id_create(struct vfs_handle_struct *handle,
2327 const SMB_STRUCT_STAT *sbuf)
2329 VFS_FIND(file_id_create);
2330 return handle->fns->file_id_create_fn(handle, sbuf);
2333 NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle,
2334 struct files_struct *fsp,
2335 const struct smb_filename *smb_fname,
2336 TALLOC_CTX *mem_ctx,
2337 unsigned int *num_streams,
2338 struct stream_struct **streams)
2340 VFS_FIND(streaminfo);
2341 return handle->fns->streaminfo_fn(handle, fsp, smb_fname, mem_ctx,
2342 num_streams, streams);
2345 int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle,
2346 const char *path, const char *name,
2347 TALLOC_CTX *mem_ctx, char **found_name)
2349 VFS_FIND(get_real_filename);
2350 return handle->fns->get_real_filename_fn(handle, path, name, mem_ctx,
2354 const char *smb_vfs_call_connectpath(struct vfs_handle_struct *handle,
2355 const struct smb_filename *smb_fname)
2357 VFS_FIND(connectpath);
2358 return handle->fns->connectpath_fn(handle, smb_fname);
2361 bool smb_vfs_call_strict_lock_check(struct vfs_handle_struct *handle,
2362 struct files_struct *fsp,
2363 struct lock_struct *plock)
2365 VFS_FIND(strict_lock_check);
2366 return handle->fns->strict_lock_check_fn(handle, fsp, plock);
2369 NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
2371 enum vfs_translate_direction direction,
2372 TALLOC_CTX *mem_ctx,
2375 VFS_FIND(translate_name);
2376 return handle->fns->translate_name_fn(handle, name, direction, mem_ctx,
2380 NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle,
2381 struct files_struct *fsp,
2385 const uint8_t *in_data,
2388 uint32_t max_out_len,
2392 return handle->fns->fsctl_fn(handle, fsp, ctx, function, req_flags,
2393 in_data, in_len, out_data, max_out_len,
2397 NTSTATUS smb_vfs_call_get_dos_attributes(struct vfs_handle_struct *handle,
2398 struct smb_filename *smb_fname,
2401 VFS_FIND(get_dos_attributes);
2402 return handle->fns->get_dos_attributes_fn(handle, smb_fname, dosmode);
2405 NTSTATUS smb_vfs_call_fget_dos_attributes(struct vfs_handle_struct *handle,
2406 struct files_struct *fsp,
2409 VFS_FIND(fget_dos_attributes);
2410 return handle->fns->fget_dos_attributes_fn(handle, fsp, dosmode);
2413 NTSTATUS smb_vfs_call_set_dos_attributes(struct vfs_handle_struct *handle,
2414 const struct smb_filename *smb_fname,
2417 VFS_FIND(set_dos_attributes);
2418 return handle->fns->set_dos_attributes_fn(handle, smb_fname, dosmode);
2421 NTSTATUS smb_vfs_call_fset_dos_attributes(struct vfs_handle_struct *handle,
2422 struct files_struct *fsp,
2425 VFS_FIND(set_dos_attributes);
2426 return handle->fns->fset_dos_attributes_fn(handle, fsp, dosmode);
2429 struct tevent_req *smb_vfs_call_offload_read_send(TALLOC_CTX *mem_ctx,
2430 struct tevent_context *ev,
2431 struct vfs_handle_struct *handle,
2432 struct files_struct *fsp,
2438 VFS_FIND(offload_read_send);
2439 return handle->fns->offload_read_send_fn(mem_ctx, ev, handle,
2441 ttl, offset, to_copy);
2444 NTSTATUS smb_vfs_call_offload_read_recv(struct tevent_req *req,
2445 struct vfs_handle_struct *handle,
2446 TALLOC_CTX *mem_ctx,
2447 DATA_BLOB *token_blob)
2449 VFS_FIND(offload_read_recv);
2450 return handle->fns->offload_read_recv_fn(req, handle, mem_ctx, token_blob);
2453 struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
2454 TALLOC_CTX *mem_ctx,
2455 struct tevent_context *ev,
2458 off_t transfer_offset,
2459 struct files_struct *dest_fsp,
2463 VFS_FIND(offload_write_send);
2464 return handle->fns->offload_write_send_fn(handle, mem_ctx, ev, fsctl,
2465 token, transfer_offset,
2466 dest_fsp, dest_off, num);
2469 NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
2470 struct tevent_req *req,
2473 VFS_FIND(offload_write_recv);
2474 return handle->fns->offload_write_recv_fn(handle, req, copied);
2477 NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle,
2478 TALLOC_CTX *mem_ctx,
2479 struct files_struct *fsp,
2480 struct smb_filename *smb_fname,
2481 uint16_t *_compression_fmt)
2483 VFS_FIND(get_compression);
2484 return handle->fns->get_compression_fn(handle, mem_ctx, fsp, smb_fname,
2488 NTSTATUS smb_vfs_call_set_compression(vfs_handle_struct *handle,
2489 TALLOC_CTX *mem_ctx,
2490 struct files_struct *fsp,
2491 uint16_t compression_fmt)
2493 VFS_FIND(set_compression);
2494 return handle->fns->set_compression_fn(handle, mem_ctx, fsp,
2498 NTSTATUS smb_vfs_call_snap_check_path(vfs_handle_struct *handle,
2499 TALLOC_CTX *mem_ctx,
2500 const char *service_path,
2503 VFS_FIND(snap_check_path);
2504 return handle->fns->snap_check_path_fn(handle, mem_ctx, service_path,
2508 NTSTATUS smb_vfs_call_snap_create(struct vfs_handle_struct *handle,
2509 TALLOC_CTX *mem_ctx,
2510 const char *base_volume,
2516 VFS_FIND(snap_create);
2517 return handle->fns->snap_create_fn(handle, mem_ctx, base_volume, tstamp,
2518 rw, base_path, snap_path);
2521 NTSTATUS smb_vfs_call_snap_delete(struct vfs_handle_struct *handle,
2522 TALLOC_CTX *mem_ctx,
2526 VFS_FIND(snap_delete);
2527 return handle->fns->snap_delete_fn(handle, mem_ctx, base_path,
2531 NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle,
2532 struct files_struct *fsp,
2533 uint32_t security_info,
2534 TALLOC_CTX *mem_ctx,
2535 struct security_descriptor **ppdesc)
2537 VFS_FIND(fget_nt_acl);
2538 return handle->fns->fget_nt_acl_fn(handle, fsp, security_info,
2542 NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle,
2543 const struct smb_filename *smb_fname,
2544 uint32_t security_info,
2545 TALLOC_CTX *mem_ctx,
2546 struct security_descriptor **ppdesc)
2548 VFS_FIND(get_nt_acl);
2549 return handle->fns->get_nt_acl_fn(handle,
2556 NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle,
2557 struct files_struct *fsp,
2558 uint32_t security_info_sent,
2559 const struct security_descriptor *psd)
2561 VFS_FIND(fset_nt_acl);
2562 return handle->fns->fset_nt_acl_fn(handle, fsp, security_info_sent,
2566 NTSTATUS smb_vfs_call_audit_file(struct vfs_handle_struct *handle,
2567 struct smb_filename *file,
2568 struct security_acl *sacl,
2569 uint32_t access_requested,
2570 uint32_t access_denied)
2572 VFS_FIND(audit_file);
2573 return handle->fns->audit_file_fn(handle,
2580 int smb_vfs_call_chmod_acl(struct vfs_handle_struct *handle,
2581 const struct smb_filename *smb_fname,
2584 VFS_FIND(chmod_acl);
2585 return handle->fns->chmod_acl_fn(handle, smb_fname, mode);
2588 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct *handle,
2589 struct files_struct *fsp, mode_t mode)
2591 VFS_FIND(fchmod_acl);
2592 return handle->fns->fchmod_acl_fn(handle, fsp, mode);
2595 SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle,
2596 const struct smb_filename *smb_fname,
2597 SMB_ACL_TYPE_T type,
2598 TALLOC_CTX *mem_ctx)
2600 VFS_FIND(sys_acl_get_file);
2601 return handle->fns->sys_acl_get_file_fn(handle, smb_fname, type, mem_ctx);
2604 SMB_ACL_T smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct *handle,
2605 struct files_struct *fsp,
2606 TALLOC_CTX *mem_ctx)
2608 VFS_FIND(sys_acl_get_fd);
2609 return handle->fns->sys_acl_get_fd_fn(handle, fsp, mem_ctx);
2612 int smb_vfs_call_sys_acl_blob_get_file(struct vfs_handle_struct *handle,
2613 const struct smb_filename *smb_fname,
2614 TALLOC_CTX *mem_ctx,
2615 char **blob_description,
2618 VFS_FIND(sys_acl_blob_get_file);
2619 return handle->fns->sys_acl_blob_get_file_fn(handle, smb_fname,
2620 mem_ctx, blob_description, blob);
2623 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct *handle,
2624 struct files_struct *fsp,
2625 TALLOC_CTX *mem_ctx,
2626 char **blob_description,
2629 VFS_FIND(sys_acl_blob_get_fd);
2630 return handle->fns->sys_acl_blob_get_fd_fn(handle, fsp, mem_ctx, blob_description, blob);
2633 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle,
2634 const struct smb_filename *smb_fname,
2635 SMB_ACL_TYPE_T acltype,
2638 VFS_FIND(sys_acl_set_file);
2639 return handle->fns->sys_acl_set_file_fn(handle, smb_fname,
2643 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct *handle,
2644 struct files_struct *fsp, SMB_ACL_T theacl)
2646 VFS_FIND(sys_acl_set_fd);
2647 return handle->fns->sys_acl_set_fd_fn(handle, fsp, theacl);
2650 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct *handle,
2651 const struct smb_filename *smb_fname)
2653 VFS_FIND(sys_acl_delete_def_file);
2654 return handle->fns->sys_acl_delete_def_file_fn(handle, smb_fname);
2657 ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle,
2658 const struct smb_filename *smb_fname,
2664 return handle->fns->getxattr_fn(handle, smb_fname, name, value, size);
2667 ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle,
2668 struct files_struct *fsp, const char *name,
2669 void *value, size_t size)
2671 VFS_FIND(fgetxattr);
2672 return handle->fns->fgetxattr_fn(handle, fsp, name, value, size);
2675 ssize_t smb_vfs_call_listxattr(struct vfs_handle_struct *handle,
2676 const struct smb_filename *smb_fname,
2680 VFS_FIND(listxattr);
2681 return handle->fns->listxattr_fn(handle, smb_fname, list, size);
2684 ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle,
2685 struct files_struct *fsp, char *list,
2688 VFS_FIND(flistxattr);
2689 return handle->fns->flistxattr_fn(handle, fsp, list, size);
2692 int smb_vfs_call_removexattr(struct vfs_handle_struct *handle,
2693 const struct smb_filename *smb_fname,
2696 VFS_FIND(removexattr);
2697 return handle->fns->removexattr_fn(handle, smb_fname, name);
2700 int smb_vfs_call_fremovexattr(struct vfs_handle_struct *handle,
2701 struct files_struct *fsp, const char *name)
2703 VFS_FIND(fremovexattr);
2704 return handle->fns->fremovexattr_fn(handle, fsp, name);
2707 int smb_vfs_call_setxattr(struct vfs_handle_struct *handle,
2708 const struct smb_filename *smb_fname,
2715 return handle->fns->setxattr_fn(handle, smb_fname,
2716 name, value, size, flags);
2719 int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle,
2720 struct files_struct *fsp, const char *name,
2721 const void *value, size_t size, int flags)
2723 VFS_FIND(fsetxattr);
2724 return handle->fns->fsetxattr_fn(handle, fsp, name, value, size, flags);
2727 bool smb_vfs_call_aio_force(struct vfs_handle_struct *handle,
2728 struct files_struct *fsp)
2730 VFS_FIND(aio_force);
2731 return handle->fns->aio_force_fn(handle, fsp);
2734 NTSTATUS smb_vfs_call_durable_cookie(struct vfs_handle_struct *handle,
2735 struct files_struct *fsp,
2736 TALLOC_CTX *mem_ctx,
2739 VFS_FIND(durable_cookie);
2740 return handle->fns->durable_cookie_fn(handle, fsp, mem_ctx, cookie);
2743 NTSTATUS smb_vfs_call_durable_disconnect(struct vfs_handle_struct *handle,
2744 struct files_struct *fsp,
2745 const DATA_BLOB old_cookie,
2746 TALLOC_CTX *mem_ctx,
2747 DATA_BLOB *new_cookie)
2749 VFS_FIND(durable_disconnect);
2750 return handle->fns->durable_disconnect_fn(handle, fsp, old_cookie,
2751 mem_ctx, new_cookie);
2754 NTSTATUS smb_vfs_call_durable_reconnect(struct vfs_handle_struct *handle,
2755 struct smb_request *smb1req,
2756 struct smbXsrv_open *op,
2757 const DATA_BLOB old_cookie,
2758 TALLOC_CTX *mem_ctx,
2759 struct files_struct **fsp,
2760 DATA_BLOB *new_cookie)
2762 VFS_FIND(durable_reconnect);
2763 return handle->fns->durable_reconnect_fn(handle, smb1req, op,
2764 old_cookie, mem_ctx, fsp,
2768 NTSTATUS smb_vfs_call_readdir_attr(struct vfs_handle_struct *handle,
2769 const struct smb_filename *fname,
2770 TALLOC_CTX *mem_ctx,
2771 struct readdir_attr_data **attr_data)
2773 VFS_FIND(readdir_attr);
2774 return handle->fns->readdir_attr_fn(handle, fname, mem_ctx, attr_data);