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 char *path
)
863 LastDir
= SMB_STRDUP("");
870 if (*path
== '/' && strcsequal(LastDir
,path
)) {
874 DEBUG(4,("vfs_ChDir to %s\n",path
));
876 ret
= SMB_VFS_CHDIR(conn
,path
);
880 LastDir
= SMB_STRDUP(path
);
883 TALLOC_FREE(conn
->cwd
);
884 conn
->cwd
= vfs_GetWd(conn
, conn
);
885 DEBUG(4,("vfs_ChDir got %s\n",conn
->cwd
));
890 /*******************************************************************
891 Return the absolute current directory path - given a UNIX pathname.
892 Note that this path is returned in DOS format, not UNIX
893 format. Note this can be called with conn == NULL.
894 ********************************************************************/
896 char *vfs_GetWd(TALLOC_CTX
*ctx
, connection_struct
*conn
)
898 char *current_dir
= NULL
;
900 DATA_BLOB cache_value
;
902 struct smb_filename
*smb_fname_dot
= NULL
;
903 struct smb_filename
*smb_fname_full
= NULL
;
905 if (!lp_getwd_cache()) {
909 smb_fname_dot
= synthetic_smb_fname(ctx
, ".", NULL
, NULL
, 0);
910 if (smb_fname_dot
== NULL
) {
915 if (SMB_VFS_STAT(conn
, smb_fname_dot
) == -1) {
917 * Known to fail for root: the directory may be NFS-mounted
918 * and exported with root_squash (so has no root access).
920 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
921 "(NFS problem ?)\n", strerror(errno
) ));
925 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
927 if (!memcache_lookup(smbd_memcache(), GETWD_CACHE
,
928 data_blob_const(&key
, sizeof(key
)),
933 SMB_ASSERT((cache_value
.length
> 0)
934 && (cache_value
.data
[cache_value
.length
-1] == '\0'));
936 smb_fname_full
= synthetic_smb_fname(ctx
, (char *)cache_value
.data
,
938 if (smb_fname_full
== NULL
) {
943 if ((SMB_VFS_STAT(conn
, smb_fname_full
) == 0) &&
944 (smb_fname_dot
->st
.st_ex_dev
== smb_fname_full
->st
.st_ex_dev
) &&
945 (smb_fname_dot
->st
.st_ex_ino
== smb_fname_full
->st
.st_ex_ino
) &&
946 (S_ISDIR(smb_fname_dot
->st
.st_ex_mode
))) {
950 result
= talloc_strdup(ctx
, smb_fname_full
->base_name
);
951 if (result
== NULL
) {
960 * We don't have the information to hand so rely on traditional
961 * methods. The very slow getcwd, which spawns a process on some
962 * systems, or the not quite so bad getwd.
965 current_dir
= SMB_VFS_GETWD(conn
);
966 if (current_dir
== NULL
) {
967 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
972 if (lp_getwd_cache() && VALID_STAT(smb_fname_dot
->st
)) {
973 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
975 memcache_add(smbd_memcache(), GETWD_CACHE
,
976 data_blob_const(&key
, sizeof(key
)),
977 data_blob_const(current_dir
,
978 strlen(current_dir
)+1));
981 result
= talloc_strdup(ctx
, current_dir
);
982 if (result
== NULL
) {
987 TALLOC_FREE(smb_fname_dot
);
988 TALLOC_FREE(smb_fname_full
);
989 SAFE_FREE(current_dir
);
993 /*******************************************************************
994 Reduce a file name, removing .. elements and checking that
995 it is below dir in the heirachy. This uses realpath.
996 This function must run as root, and will return names
997 and valid stat structs that can be checked on open.
998 ********************************************************************/
1000 NTSTATUS
check_reduced_name_with_privilege(connection_struct
*conn
,
1002 struct smb_request
*smbreq
)
1005 TALLOC_CTX
*ctx
= talloc_tos();
1006 const char *conn_rootdir
;
1008 char *dir_name
= NULL
;
1009 const char *last_component
= NULL
;
1010 char *resolved_name
= NULL
;
1011 char *saved_dir
= NULL
;
1012 struct smb_filename
*smb_fname_cwd
= NULL
;
1013 struct privilege_paths
*priv_paths
= NULL
;
1016 DEBUG(3,("check_reduced_name_with_privilege [%s] [%s]\n",
1018 conn
->connectpath
));
1021 priv_paths
= talloc_zero(smbreq
, struct privilege_paths
);
1023 status
= NT_STATUS_NO_MEMORY
;
1027 if (!parent_dirname(ctx
, fname
, &dir_name
, &last_component
)) {
1028 status
= NT_STATUS_NO_MEMORY
;
1032 priv_paths
->parent_name
.base_name
= talloc_strdup(priv_paths
, dir_name
);
1033 priv_paths
->file_name
.base_name
= talloc_strdup(priv_paths
, last_component
);
1035 if (priv_paths
->parent_name
.base_name
== NULL
||
1036 priv_paths
->file_name
.base_name
== NULL
) {
1037 status
= NT_STATUS_NO_MEMORY
;
1041 if (SMB_VFS_STAT(conn
, &priv_paths
->parent_name
) != 0) {
1042 status
= map_nt_error_from_unix(errno
);
1045 /* Remember where we were. */
1046 saved_dir
= vfs_GetWd(ctx
, conn
);
1048 status
= map_nt_error_from_unix(errno
);
1052 /* Go to the parent directory to lock in memory. */
1053 if (vfs_ChDir(conn
, priv_paths
->parent_name
.base_name
) == -1) {
1054 status
= map_nt_error_from_unix(errno
);
1058 /* Get the absolute path of the parent directory. */
1059 resolved_name
= SMB_VFS_REALPATH(conn
,".");
1060 if (!resolved_name
) {
1061 status
= map_nt_error_from_unix(errno
);
1065 if (*resolved_name
!= '/') {
1066 DEBUG(0,("check_reduced_name_with_privilege: realpath "
1067 "doesn't return absolute paths !\n"));
1068 status
= NT_STATUS_OBJECT_NAME_INVALID
;
1072 DEBUG(10,("check_reduced_name_with_privilege: realpath [%s] -> [%s]\n",
1073 priv_paths
->parent_name
.base_name
,
1076 /* Now check the stat value is the same. */
1077 smb_fname_cwd
= synthetic_smb_fname(talloc_tos(), ".", NULL
, NULL
, 0);
1078 if (smb_fname_cwd
== NULL
) {
1079 status
= NT_STATUS_NO_MEMORY
;
1083 if (SMB_VFS_LSTAT(conn
, smb_fname_cwd
) != 0) {
1084 status
= map_nt_error_from_unix(errno
);
1088 /* Ensure we're pointing at the same place. */
1089 if (!check_same_stat(&smb_fname_cwd
->st
, &priv_paths
->parent_name
.st
)) {
1090 DEBUG(0,("check_reduced_name_with_privilege: "
1091 "device/inode/uid/gid on directory %s changed. "
1092 "Denying access !\n",
1093 priv_paths
->parent_name
.base_name
));
1094 status
= NT_STATUS_ACCESS_DENIED
;
1098 /* Ensure we're below the connect path. */
1100 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, fname
);
1101 if (conn_rootdir
== NULL
) {
1102 DEBUG(2, ("check_reduced_name_with_privilege: Could not get "
1104 status
= NT_STATUS_ACCESS_DENIED
;
1108 rootdir_len
= strlen(conn_rootdir
);
1111 * In the case of rootdir_len == 1, we know that conn_rootdir is
1112 * "/", and we also know that resolved_name starts with a slash.
1113 * So, in this corner case, resolved_name is automatically a
1114 * sub-directory of the conn_rootdir. Thus we can skip the string
1115 * comparison and the next character checks (which are even
1116 * wrong in this case).
1118 if (rootdir_len
!= 1) {
1121 matched
= (strncmp(conn_rootdir
, resolved_name
,
1124 if (!matched
|| (resolved_name
[rootdir_len
] != '/' &&
1125 resolved_name
[rootdir_len
] != '\0')) {
1126 DEBUG(2, ("check_reduced_name_with_privilege: Bad "
1127 "access attempt: %s is a symlink outside the "
1130 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir
));
1131 DEBUGADD(2, ("resolved_name=%s\n", resolved_name
));
1132 status
= NT_STATUS_ACCESS_DENIED
;
1137 /* Now ensure that the last component either doesn't
1138 exist, or is *NOT* a symlink. */
1140 ret
= SMB_VFS_LSTAT(conn
, &priv_paths
->file_name
);
1142 /* Errno must be ENOENT for this be ok. */
1143 if (errno
!= ENOENT
) {
1144 status
= map_nt_error_from_unix(errno
);
1145 DEBUG(2, ("check_reduced_name_with_privilege: "
1146 "LSTAT on %s failed with %s\n",
1147 priv_paths
->file_name
.base_name
,
1148 nt_errstr(status
)));
1153 if (VALID_STAT(priv_paths
->file_name
.st
) &&
1154 S_ISLNK(priv_paths
->file_name
.st
.st_ex_mode
)) {
1155 DEBUG(2, ("check_reduced_name_with_privilege: "
1156 "Last component %s is a symlink. Denying"
1158 priv_paths
->file_name
.base_name
));
1159 status
= NT_STATUS_ACCESS_DENIED
;
1163 smbreq
->priv_paths
= priv_paths
;
1164 status
= NT_STATUS_OK
;
1169 vfs_ChDir(conn
, saved_dir
);
1171 SAFE_FREE(resolved_name
);
1172 if (!NT_STATUS_IS_OK(status
)) {
1173 TALLOC_FREE(priv_paths
);
1175 TALLOC_FREE(dir_name
);
1179 /*******************************************************************
1180 Reduce a file name, removing .. elements and checking that
1181 it is below dir in the heirachy. This uses realpath.
1183 If cwd_name == NULL then fname is a client given path relative
1184 to the root path of the share.
1186 If cwd_name != NULL then fname is a client given path relative
1187 to cwd_name. cwd_name is relative to the root path of the share.
1188 ********************************************************************/
1190 NTSTATUS
check_reduced_name(connection_struct
*conn
,
1191 const char *cwd_name
,
1194 char *resolved_name
= NULL
;
1195 char *new_fname
= NULL
;
1196 bool allow_symlinks
= true;
1197 bool allow_widelinks
= false;
1199 DBG_DEBUG("check_reduced_name [%s] [%s]\n", fname
, conn
->connectpath
);
1201 resolved_name
= SMB_VFS_REALPATH(conn
,fname
);
1203 if (!resolved_name
) {
1206 DEBUG(3,("check_reduced_name: Component not a "
1207 "directory in getting realpath for "
1209 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1212 TALLOC_CTX
*ctx
= talloc_tos();
1213 char *dir_name
= NULL
;
1214 const char *last_component
= NULL
;
1215 char *new_name
= NULL
;
1218 /* Last component didn't exist.
1219 Remove it and try and canonicalise
1220 the directory name. */
1221 if (!parent_dirname(ctx
, fname
,
1224 return NT_STATUS_NO_MEMORY
;
1227 resolved_name
= SMB_VFS_REALPATH(conn
,dir_name
);
1228 if (!resolved_name
) {
1229 NTSTATUS status
= map_nt_error_from_unix(errno
);
1231 if (errno
== ENOENT
|| errno
== ENOTDIR
) {
1232 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1235 DEBUG(3,("check_reduce_name: "
1236 "couldn't get realpath for "
1239 nt_errstr(status
)));
1242 ret
= asprintf(&new_name
, "%s/%s",
1243 resolved_name
, last_component
);
1244 SAFE_FREE(resolved_name
);
1246 return NT_STATUS_NO_MEMORY
;
1248 resolved_name
= new_name
;
1252 DEBUG(3,("check_reduced_name: couldn't get "
1253 "realpath for %s\n", fname
));
1254 return map_nt_error_from_unix(errno
);
1258 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname
,
1261 if (*resolved_name
!= '/') {
1262 DEBUG(0,("check_reduced_name: realpath doesn't return "
1263 "absolute paths !\n"));
1264 SAFE_FREE(resolved_name
);
1265 return NT_STATUS_OBJECT_NAME_INVALID
;
1268 allow_widelinks
= lp_widelinks(SNUM(conn
));
1269 allow_symlinks
= lp_follow_symlinks(SNUM(conn
));
1271 /* Common widelinks and symlinks checks. */
1272 if (!allow_widelinks
|| !allow_symlinks
) {
1273 const char *conn_rootdir
;
1276 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, fname
);
1277 if (conn_rootdir
== NULL
) {
1278 DEBUG(2, ("check_reduced_name: Could not get "
1280 SAFE_FREE(resolved_name
);
1281 return NT_STATUS_ACCESS_DENIED
;
1284 rootdir_len
= strlen(conn_rootdir
);
1287 * In the case of rootdir_len == 1, we know that
1288 * conn_rootdir is "/", and we also know that
1289 * resolved_name starts with a slash. So, in this
1290 * corner case, resolved_name is automatically a
1291 * sub-directory of the conn_rootdir. Thus we can skip
1292 * the string comparison and the next character checks
1293 * (which are even wrong in this case).
1295 if (rootdir_len
!= 1) {
1298 matched
= (strncmp(conn_rootdir
, resolved_name
,
1300 if (!matched
|| (resolved_name
[rootdir_len
] != '/' &&
1301 resolved_name
[rootdir_len
] != '\0')) {
1302 DEBUG(2, ("check_reduced_name: Bad access "
1303 "attempt: %s is a symlink outside the "
1304 "share path\n", fname
));
1305 DEBUGADD(2, ("conn_rootdir =%s\n",
1307 DEBUGADD(2, ("resolved_name=%s\n",
1309 SAFE_FREE(resolved_name
);
1310 return NT_STATUS_ACCESS_DENIED
;
1314 /* Extra checks if all symlinks are disallowed. */
1315 if (!allow_symlinks
) {
1316 /* fname can't have changed in resolved_path. */
1317 const char *p
= &resolved_name
[rootdir_len
];
1320 * UNIX filesystem semantics, names consisting
1321 * only of "." or ".." CANNOT be symlinks.
1323 if (ISDOT(fname
) || ISDOTDOT(fname
)) {
1328 DEBUG(2, ("check_reduced_name: logic error (%c) "
1329 "in resolved_name: %s\n",
1332 SAFE_FREE(resolved_name
);
1333 return NT_STATUS_ACCESS_DENIED
;
1339 * If cwd_name is present and not ".",
1340 * then fname is relative to that, not
1341 * the root of the share. Make sure the
1342 * path we check is the one the client
1343 * sent (cwd_name+fname).
1345 if (cwd_name
!= NULL
&& !ISDOT(cwd_name
)) {
1346 new_fname
= talloc_asprintf(talloc_tos(),
1350 if (new_fname
== NULL
) {
1351 SAFE_FREE(resolved_name
);
1352 return NT_STATUS_NO_MEMORY
;
1357 if (strcmp(fname
, p
)!=0) {
1358 DEBUG(2, ("check_reduced_name: Bad access "
1359 "attempt: %s is a symlink to %s\n",
1361 SAFE_FREE(resolved_name
);
1362 TALLOC_FREE(new_fname
);
1363 return NT_STATUS_ACCESS_DENIED
;
1370 DBG_INFO("%s reduced to %s\n", fname
, resolved_name
);
1371 SAFE_FREE(resolved_name
);
1372 TALLOC_FREE(new_fname
);
1373 return NT_STATUS_OK
;
1377 * XXX: This is temporary and there should be no callers of this once
1378 * smb_filename is plumbed through all path based operations.
1380 * Called when we know stream name parsing has already been done.
1382 int vfs_stat_smb_basename(struct connection_struct
*conn
,
1383 const struct smb_filename
*smb_fname_in
,
1384 SMB_STRUCT_STAT
*psbuf
)
1386 struct smb_filename smb_fname
= {
1387 .base_name
= discard_const_p(char, smb_fname_in
->base_name
),
1388 .flags
= smb_fname_in
->flags
1392 if (smb_fname
.flags
& SMB_FILENAME_POSIX_PATH
) {
1393 ret
= SMB_VFS_LSTAT(conn
, &smb_fname
);
1395 ret
= SMB_VFS_STAT(conn
, &smb_fname
);
1399 *psbuf
= smb_fname
.st
;
1405 * Ensure LSTAT is called for POSIX paths.
1408 NTSTATUS
vfs_stat_fsp(files_struct
*fsp
)
1412 if(fsp
->fh
->fd
== -1) {
1413 if (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) {
1414 ret
= SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1416 ret
= SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1419 return map_nt_error_from_unix(errno
);
1422 if(SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) != 0) {
1423 return map_nt_error_from_unix(errno
);
1426 return NT_STATUS_OK
;
1430 * Initialize num_streams and streams, then call VFS op streaminfo
1432 NTSTATUS
vfs_streaminfo(connection_struct
*conn
,
1433 struct files_struct
*fsp
,
1434 const struct smb_filename
*smb_fname
,
1435 TALLOC_CTX
*mem_ctx
,
1436 unsigned int *num_streams
,
1437 struct stream_struct
**streams
)
1441 return SMB_VFS_STREAMINFO(conn
,
1450 generate a file_id from a stat structure
1452 struct file_id
vfs_file_id_from_sbuf(connection_struct
*conn
, const SMB_STRUCT_STAT
*sbuf
)
1454 return SMB_VFS_FILE_ID_CREATE(conn
, sbuf
);
1457 int smb_vfs_call_connect(struct vfs_handle_struct
*handle
,
1458 const char *service
, const char *user
)
1461 return handle
->fns
->connect_fn(handle
, service
, user
);
1464 void smb_vfs_call_disconnect(struct vfs_handle_struct
*handle
)
1466 VFS_FIND(disconnect
);
1467 handle
->fns
->disconnect_fn(handle
);
1470 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct
*handle
,
1471 const char *path
, uint64_t *bsize
,
1472 uint64_t *dfree
, uint64_t *dsize
)
1474 VFS_FIND(disk_free
);
1475 return handle
->fns
->disk_free_fn(handle
, path
, bsize
, dfree
, dsize
);
1478 int smb_vfs_call_get_quota(struct vfs_handle_struct
*handle
, const char *path
,
1479 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1482 VFS_FIND(get_quota
);
1483 return handle
->fns
->get_quota_fn(handle
, path
, qtype
, id
, qt
);
1486 int smb_vfs_call_set_quota(struct vfs_handle_struct
*handle
,
1487 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1490 VFS_FIND(set_quota
);
1491 return handle
->fns
->set_quota_fn(handle
, qtype
, id
, qt
);
1494 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
1495 struct files_struct
*fsp
,
1496 struct shadow_copy_data
*shadow_copy_data
,
1499 VFS_FIND(get_shadow_copy_data
);
1500 return handle
->fns
->get_shadow_copy_data_fn(handle
, fsp
,
1504 int smb_vfs_call_statvfs(struct vfs_handle_struct
*handle
, const char *path
,
1505 struct vfs_statvfs_struct
*statbuf
)
1508 return handle
->fns
->statvfs_fn(handle
, path
, statbuf
);
1511 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct
*handle
,
1512 enum timestamp_set_resolution
*p_ts_res
)
1514 VFS_FIND(fs_capabilities
);
1515 return handle
->fns
->fs_capabilities_fn(handle
, p_ts_res
);
1518 NTSTATUS
smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct
*handle
,
1519 struct dfs_GetDFSReferral
*r
)
1521 VFS_FIND(get_dfs_referrals
);
1522 return handle
->fns
->get_dfs_referrals_fn(handle
, r
);
1525 DIR *smb_vfs_call_opendir(struct vfs_handle_struct
*handle
,
1526 const struct smb_filename
*smb_fname
,
1528 uint32_t attributes
)
1531 return handle
->fns
->opendir_fn(handle
, smb_fname
, mask
, attributes
);
1534 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct
*handle
,
1535 struct files_struct
*fsp
,
1537 uint32_t attributes
)
1539 VFS_FIND(fdopendir
);
1540 return handle
->fns
->fdopendir_fn(handle
, fsp
, mask
, attributes
);
1543 struct dirent
*smb_vfs_call_readdir(struct vfs_handle_struct
*handle
,
1545 SMB_STRUCT_STAT
*sbuf
)
1548 return handle
->fns
->readdir_fn(handle
, dirp
, sbuf
);
1551 void smb_vfs_call_seekdir(struct vfs_handle_struct
*handle
,
1552 DIR *dirp
, long offset
)
1555 handle
->fns
->seekdir_fn(handle
, dirp
, offset
);
1558 long smb_vfs_call_telldir(struct vfs_handle_struct
*handle
,
1562 return handle
->fns
->telldir_fn(handle
, dirp
);
1565 void smb_vfs_call_rewind_dir(struct vfs_handle_struct
*handle
,
1568 VFS_FIND(rewind_dir
);
1569 handle
->fns
->rewind_dir_fn(handle
, dirp
);
1572 int smb_vfs_call_mkdir(struct vfs_handle_struct
*handle
,
1573 const struct smb_filename
*smb_fname
,
1577 return handle
->fns
->mkdir_fn(handle
, smb_fname
, mode
);
1580 int smb_vfs_call_rmdir(struct vfs_handle_struct
*handle
,
1581 const struct smb_filename
*smb_fname
)
1584 return handle
->fns
->rmdir_fn(handle
, smb_fname
);
1587 int smb_vfs_call_closedir(struct vfs_handle_struct
*handle
,
1591 return handle
->fns
->closedir_fn(handle
, dir
);
1594 void smb_vfs_call_init_search_op(struct vfs_handle_struct
*handle
,
1597 VFS_FIND(init_search_op
);
1598 handle
->fns
->init_search_op_fn(handle
, dirp
);
1601 int smb_vfs_call_open(struct vfs_handle_struct
*handle
,
1602 struct smb_filename
*smb_fname
, struct files_struct
*fsp
,
1603 int flags
, mode_t mode
)
1606 return handle
->fns
->open_fn(handle
, smb_fname
, fsp
, flags
, mode
);
1609 NTSTATUS
smb_vfs_call_create_file(struct vfs_handle_struct
*handle
,
1610 struct smb_request
*req
,
1611 uint16_t root_dir_fid
,
1612 struct smb_filename
*smb_fname
,
1613 uint32_t access_mask
,
1614 uint32_t share_access
,
1615 uint32_t create_disposition
,
1616 uint32_t create_options
,
1617 uint32_t file_attributes
,
1618 uint32_t oplock_request
,
1619 struct smb2_lease
*lease
,
1620 uint64_t allocation_size
,
1621 uint32_t private_flags
,
1622 struct security_descriptor
*sd
,
1623 struct ea_list
*ea_list
,
1624 files_struct
**result
,
1626 const struct smb2_create_blobs
*in_context_blobs
,
1627 struct smb2_create_blobs
*out_context_blobs
)
1629 VFS_FIND(create_file
);
1630 return handle
->fns
->create_file_fn(
1631 handle
, req
, root_dir_fid
, smb_fname
, access_mask
,
1632 share_access
, create_disposition
, create_options
,
1633 file_attributes
, oplock_request
, lease
, allocation_size
,
1634 private_flags
, sd
, ea_list
,
1635 result
, pinfo
, in_context_blobs
, out_context_blobs
);
1638 int smb_vfs_call_close(struct vfs_handle_struct
*handle
,
1639 struct files_struct
*fsp
)
1642 return handle
->fns
->close_fn(handle
, fsp
);
1645 ssize_t
smb_vfs_call_read(struct vfs_handle_struct
*handle
,
1646 struct files_struct
*fsp
, void *data
, size_t n
)
1649 return handle
->fns
->read_fn(handle
, fsp
, data
, n
);
1652 ssize_t
smb_vfs_call_pread(struct vfs_handle_struct
*handle
,
1653 struct files_struct
*fsp
, void *data
, size_t n
,
1657 return handle
->fns
->pread_fn(handle
, fsp
, data
, n
, offset
);
1660 struct smb_vfs_call_pread_state
{
1661 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1663 struct vfs_aio_state vfs_aio_state
;
1666 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
);
1668 struct tevent_req
*smb_vfs_call_pread_send(struct vfs_handle_struct
*handle
,
1669 TALLOC_CTX
*mem_ctx
,
1670 struct tevent_context
*ev
,
1671 struct files_struct
*fsp
,
1673 size_t n
, off_t offset
)
1675 struct tevent_req
*req
, *subreq
;
1676 struct smb_vfs_call_pread_state
*state
;
1678 req
= tevent_req_create(mem_ctx
, &state
,
1679 struct smb_vfs_call_pread_state
);
1683 VFS_FIND(pread_send
);
1684 state
->recv_fn
= handle
->fns
->pread_recv_fn
;
1686 subreq
= handle
->fns
->pread_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1688 if (tevent_req_nomem(subreq
, req
)) {
1689 return tevent_req_post(req
, ev
);
1691 tevent_req_set_callback(subreq
, smb_vfs_call_pread_done
, req
);
1695 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
)
1697 struct tevent_req
*req
= tevent_req_callback_data(
1698 subreq
, struct tevent_req
);
1699 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1700 req
, struct smb_vfs_call_pread_state
);
1702 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1703 TALLOC_FREE(subreq
);
1704 if (state
->retval
== -1) {
1705 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1708 tevent_req_done(req
);
1711 ssize_t
SMB_VFS_PREAD_RECV(struct tevent_req
*req
,
1712 struct vfs_aio_state
*vfs_aio_state
)
1714 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1715 req
, struct smb_vfs_call_pread_state
);
1717 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1720 *vfs_aio_state
= state
->vfs_aio_state
;
1721 return state
->retval
;
1724 ssize_t
smb_vfs_call_write(struct vfs_handle_struct
*handle
,
1725 struct files_struct
*fsp
, const void *data
,
1729 return handle
->fns
->write_fn(handle
, fsp
, data
, n
);
1732 ssize_t
smb_vfs_call_pwrite(struct vfs_handle_struct
*handle
,
1733 struct files_struct
*fsp
, const void *data
,
1734 size_t n
, off_t offset
)
1737 return handle
->fns
->pwrite_fn(handle
, fsp
, data
, n
, offset
);
1740 struct smb_vfs_call_pwrite_state
{
1741 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1743 struct vfs_aio_state vfs_aio_state
;
1746 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
);
1748 struct tevent_req
*smb_vfs_call_pwrite_send(struct vfs_handle_struct
*handle
,
1749 TALLOC_CTX
*mem_ctx
,
1750 struct tevent_context
*ev
,
1751 struct files_struct
*fsp
,
1753 size_t n
, off_t offset
)
1755 struct tevent_req
*req
, *subreq
;
1756 struct smb_vfs_call_pwrite_state
*state
;
1758 req
= tevent_req_create(mem_ctx
, &state
,
1759 struct smb_vfs_call_pwrite_state
);
1763 VFS_FIND(pwrite_send
);
1764 state
->recv_fn
= handle
->fns
->pwrite_recv_fn
;
1766 subreq
= handle
->fns
->pwrite_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1768 if (tevent_req_nomem(subreq
, req
)) {
1769 return tevent_req_post(req
, ev
);
1771 tevent_req_set_callback(subreq
, smb_vfs_call_pwrite_done
, req
);
1775 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
)
1777 struct tevent_req
*req
= tevent_req_callback_data(
1778 subreq
, struct tevent_req
);
1779 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1780 req
, struct smb_vfs_call_pwrite_state
);
1782 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1783 TALLOC_FREE(subreq
);
1784 if (state
->retval
== -1) {
1785 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1788 tevent_req_done(req
);
1791 ssize_t
SMB_VFS_PWRITE_RECV(struct tevent_req
*req
,
1792 struct vfs_aio_state
*vfs_aio_state
)
1794 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1795 req
, struct smb_vfs_call_pwrite_state
);
1797 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1800 *vfs_aio_state
= state
->vfs_aio_state
;
1801 return state
->retval
;
1804 off_t
smb_vfs_call_lseek(struct vfs_handle_struct
*handle
,
1805 struct files_struct
*fsp
, off_t offset
,
1809 return handle
->fns
->lseek_fn(handle
, fsp
, offset
, whence
);
1812 ssize_t
smb_vfs_call_sendfile(struct vfs_handle_struct
*handle
, int tofd
,
1813 files_struct
*fromfsp
, const DATA_BLOB
*header
,
1814 off_t offset
, size_t count
)
1817 return handle
->fns
->sendfile_fn(handle
, tofd
, fromfsp
, header
, offset
,
1821 ssize_t
smb_vfs_call_recvfile(struct vfs_handle_struct
*handle
, int fromfd
,
1822 files_struct
*tofsp
, off_t offset
,
1826 return handle
->fns
->recvfile_fn(handle
, fromfd
, tofsp
, offset
, count
);
1829 int smb_vfs_call_rename(struct vfs_handle_struct
*handle
,
1830 const struct smb_filename
*smb_fname_src
,
1831 const struct smb_filename
*smb_fname_dst
)
1834 return handle
->fns
->rename_fn(handle
, smb_fname_src
, smb_fname_dst
);
1837 int smb_vfs_call_fsync(struct vfs_handle_struct
*handle
,
1838 struct files_struct
*fsp
)
1841 return handle
->fns
->fsync_fn(handle
, fsp
);
1844 struct smb_vfs_call_fsync_state
{
1845 int (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1847 struct vfs_aio_state vfs_aio_state
;
1850 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
);
1852 struct tevent_req
*smb_vfs_call_fsync_send(struct vfs_handle_struct
*handle
,
1853 TALLOC_CTX
*mem_ctx
,
1854 struct tevent_context
*ev
,
1855 struct files_struct
*fsp
)
1857 struct tevent_req
*req
, *subreq
;
1858 struct smb_vfs_call_fsync_state
*state
;
1860 req
= tevent_req_create(mem_ctx
, &state
,
1861 struct smb_vfs_call_fsync_state
);
1865 VFS_FIND(fsync_send
);
1866 state
->recv_fn
= handle
->fns
->fsync_recv_fn
;
1868 subreq
= handle
->fns
->fsync_send_fn(handle
, state
, ev
, fsp
);
1869 if (tevent_req_nomem(subreq
, req
)) {
1870 return tevent_req_post(req
, ev
);
1872 tevent_req_set_callback(subreq
, smb_vfs_call_fsync_done
, req
);
1876 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
)
1878 struct tevent_req
*req
= tevent_req_callback_data(
1879 subreq
, struct tevent_req
);
1880 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1881 req
, struct smb_vfs_call_fsync_state
);
1883 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1884 TALLOC_FREE(subreq
);
1885 if (state
->retval
== -1) {
1886 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1889 tevent_req_done(req
);
1892 int SMB_VFS_FSYNC_RECV(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
)
1894 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1895 req
, struct smb_vfs_call_fsync_state
);
1897 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1900 *vfs_aio_state
= state
->vfs_aio_state
;
1901 return state
->retval
;
1905 int smb_vfs_call_stat(struct vfs_handle_struct
*handle
,
1906 struct smb_filename
*smb_fname
)
1909 return handle
->fns
->stat_fn(handle
, smb_fname
);
1912 int smb_vfs_call_fstat(struct vfs_handle_struct
*handle
,
1913 struct files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
1916 return handle
->fns
->fstat_fn(handle
, fsp
, sbuf
);
1919 int smb_vfs_call_lstat(struct vfs_handle_struct
*handle
,
1920 struct smb_filename
*smb_filename
)
1923 return handle
->fns
->lstat_fn(handle
, smb_filename
);
1926 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct
*handle
,
1927 struct files_struct
*fsp
,
1928 const SMB_STRUCT_STAT
*sbuf
)
1930 VFS_FIND(get_alloc_size
);
1931 return handle
->fns
->get_alloc_size_fn(handle
, fsp
, sbuf
);
1934 int smb_vfs_call_unlink(struct vfs_handle_struct
*handle
,
1935 const struct smb_filename
*smb_fname
)
1938 return handle
->fns
->unlink_fn(handle
, smb_fname
);
1941 int smb_vfs_call_chmod(struct vfs_handle_struct
*handle
,
1942 const struct smb_filename
*smb_fname
,
1946 return handle
->fns
->chmod_fn(handle
, smb_fname
, mode
);
1949 int smb_vfs_call_fchmod(struct vfs_handle_struct
*handle
,
1950 struct files_struct
*fsp
, mode_t mode
)
1953 return handle
->fns
->fchmod_fn(handle
, fsp
, mode
);
1956 int smb_vfs_call_chown(struct vfs_handle_struct
*handle
,
1957 const struct smb_filename
*smb_fname
,
1962 return handle
->fns
->chown_fn(handle
, smb_fname
, uid
, gid
);
1965 int smb_vfs_call_fchown(struct vfs_handle_struct
*handle
,
1966 struct files_struct
*fsp
, uid_t uid
, gid_t gid
)
1969 return handle
->fns
->fchown_fn(handle
, fsp
, uid
, gid
);
1972 int smb_vfs_call_lchown(struct vfs_handle_struct
*handle
,
1973 const struct smb_filename
*smb_fname
,
1978 return handle
->fns
->lchown_fn(handle
, smb_fname
, uid
, gid
);
1981 NTSTATUS
vfs_chown_fsp(files_struct
*fsp
, uid_t uid
, gid_t gid
)
1984 bool as_root
= false;
1987 if (fsp
->fh
->fd
!= -1) {
1989 ret
= SMB_VFS_FCHOWN(fsp
, uid
, gid
);
1991 return NT_STATUS_OK
;
1993 if (ret
== -1 && errno
!= ENOSYS
) {
1994 return map_nt_error_from_unix(errno
);
1998 as_root
= (geteuid() == 0);
2002 * We are being asked to chown as root. Make
2003 * sure we chdir() into the path to pin it,
2004 * and always act using lchown to ensure we
2005 * don't deref any symbolic links.
2007 char *saved_dir
= NULL
;
2008 char *parent_dir
= NULL
;
2009 const char *final_component
= NULL
;
2010 struct smb_filename
*local_smb_fname
= NULL
;
2012 saved_dir
= vfs_GetWd(talloc_tos(),fsp
->conn
);
2014 status
= map_nt_error_from_unix(errno
);
2015 DEBUG(0,("vfs_chown_fsp: failed to get "
2016 "current working directory. Error was %s\n",
2021 if (!parent_dirname(talloc_tos(),
2022 fsp
->fsp_name
->base_name
,
2024 &final_component
)) {
2025 return NT_STATUS_NO_MEMORY
;
2028 /* cd into the parent dir to pin it. */
2029 ret
= vfs_ChDir(fsp
->conn
, parent_dir
);
2031 return map_nt_error_from_unix(errno
);
2034 local_smb_fname
= synthetic_smb_fname(talloc_tos(),
2038 fsp
->fsp_name
->flags
);
2039 if (local_smb_fname
== NULL
) {
2040 status
= NT_STATUS_NO_MEMORY
;
2044 /* Must use lstat here. */
2045 ret
= SMB_VFS_LSTAT(fsp
->conn
, local_smb_fname
);
2047 status
= map_nt_error_from_unix(errno
);
2051 /* Ensure it matches the fsp stat. */
2052 if (!check_same_stat(&local_smb_fname
->st
,
2053 &fsp
->fsp_name
->st
)) {
2054 status
= NT_STATUS_ACCESS_DENIED
;
2058 ret
= SMB_VFS_LCHOWN(fsp
->conn
,
2063 status
= NT_STATUS_OK
;
2065 status
= map_nt_error_from_unix(errno
);
2070 vfs_ChDir(fsp
->conn
,saved_dir
);
2071 TALLOC_FREE(local_smb_fname
);
2072 TALLOC_FREE(saved_dir
);
2073 TALLOC_FREE(parent_dir
);
2078 if (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) {
2079 ret
= SMB_VFS_LCHOWN(fsp
->conn
,
2083 ret
= SMB_VFS_CHOWN(fsp
->conn
,
2089 status
= NT_STATUS_OK
;
2091 status
= map_nt_error_from_unix(errno
);
2096 int smb_vfs_call_chdir(struct vfs_handle_struct
*handle
, const char *path
)
2099 return handle
->fns
->chdir_fn(handle
, path
);
2102 char *smb_vfs_call_getwd(struct vfs_handle_struct
*handle
)
2105 return handle
->fns
->getwd_fn(handle
);
2108 int smb_vfs_call_ntimes(struct vfs_handle_struct
*handle
,
2109 const struct smb_filename
*smb_fname
,
2110 struct smb_file_time
*ft
)
2113 return handle
->fns
->ntimes_fn(handle
, smb_fname
, ft
);
2116 int smb_vfs_call_ftruncate(struct vfs_handle_struct
*handle
,
2117 struct files_struct
*fsp
, off_t offset
)
2119 VFS_FIND(ftruncate
);
2120 return handle
->fns
->ftruncate_fn(handle
, fsp
, offset
);
2123 int smb_vfs_call_fallocate(struct vfs_handle_struct
*handle
,
2124 struct files_struct
*fsp
,
2129 VFS_FIND(fallocate
);
2130 return handle
->fns
->fallocate_fn(handle
, fsp
, mode
, offset
, len
);
2133 int smb_vfs_call_kernel_flock(struct vfs_handle_struct
*handle
,
2134 struct files_struct
*fsp
, uint32_t share_mode
,
2135 uint32_t access_mask
)
2137 VFS_FIND(kernel_flock
);
2138 return handle
->fns
->kernel_flock_fn(handle
, fsp
, share_mode
,
2142 int smb_vfs_call_linux_setlease(struct vfs_handle_struct
*handle
,
2143 struct files_struct
*fsp
, int leasetype
)
2145 VFS_FIND(linux_setlease
);
2146 return handle
->fns
->linux_setlease_fn(handle
, fsp
, leasetype
);
2149 int smb_vfs_call_symlink(struct vfs_handle_struct
*handle
, const char *oldpath
,
2150 const char *newpath
)
2153 return handle
->fns
->symlink_fn(handle
, oldpath
, newpath
);
2156 int smb_vfs_call_readlink(struct vfs_handle_struct
*handle
,
2157 const char *path
, char *buf
, size_t bufsiz
)
2160 return handle
->fns
->readlink_fn(handle
, path
, buf
, bufsiz
);
2163 int smb_vfs_call_link(struct vfs_handle_struct
*handle
, const char *oldpath
,
2164 const char *newpath
)
2167 return handle
->fns
->link_fn(handle
, oldpath
, newpath
);
2170 int smb_vfs_call_mknod(struct vfs_handle_struct
*handle
,
2171 const struct smb_filename
*smb_fname
,
2176 return handle
->fns
->mknod_fn(handle
, smb_fname
, mode
, dev
);
2179 char *smb_vfs_call_realpath(struct vfs_handle_struct
*handle
, const char *path
)
2182 return handle
->fns
->realpath_fn(handle
, path
);
2185 int smb_vfs_call_chflags(struct vfs_handle_struct
*handle
, const char *path
,
2189 return handle
->fns
->chflags_fn(handle
, path
, flags
);
2192 struct file_id
smb_vfs_call_file_id_create(struct vfs_handle_struct
*handle
,
2193 const SMB_STRUCT_STAT
*sbuf
)
2195 VFS_FIND(file_id_create
);
2196 return handle
->fns
->file_id_create_fn(handle
, sbuf
);
2199 NTSTATUS
smb_vfs_call_streaminfo(struct vfs_handle_struct
*handle
,
2200 struct files_struct
*fsp
,
2201 const struct smb_filename
*smb_fname
,
2202 TALLOC_CTX
*mem_ctx
,
2203 unsigned int *num_streams
,
2204 struct stream_struct
**streams
)
2206 VFS_FIND(streaminfo
);
2207 return handle
->fns
->streaminfo_fn(handle
, fsp
, smb_fname
, mem_ctx
,
2208 num_streams
, streams
);
2211 int smb_vfs_call_get_real_filename(struct vfs_handle_struct
*handle
,
2212 const char *path
, const char *name
,
2213 TALLOC_CTX
*mem_ctx
, char **found_name
)
2215 VFS_FIND(get_real_filename
);
2216 return handle
->fns
->get_real_filename_fn(handle
, path
, name
, mem_ctx
,
2220 const char *smb_vfs_call_connectpath(struct vfs_handle_struct
*handle
,
2221 const char *filename
)
2223 VFS_FIND(connectpath
);
2224 return handle
->fns
->connectpath_fn(handle
, filename
);
2227 bool smb_vfs_call_strict_lock(struct vfs_handle_struct
*handle
,
2228 struct files_struct
*fsp
,
2229 struct lock_struct
*plock
)
2231 VFS_FIND(strict_lock
);
2232 return handle
->fns
->strict_lock_fn(handle
, fsp
, plock
);
2235 void smb_vfs_call_strict_unlock(struct vfs_handle_struct
*handle
,
2236 struct files_struct
*fsp
,
2237 struct lock_struct
*plock
)
2239 VFS_FIND(strict_unlock
);
2240 handle
->fns
->strict_unlock_fn(handle
, fsp
, plock
);
2243 NTSTATUS
smb_vfs_call_translate_name(struct vfs_handle_struct
*handle
,
2245 enum vfs_translate_direction direction
,
2246 TALLOC_CTX
*mem_ctx
,
2249 VFS_FIND(translate_name
);
2250 return handle
->fns
->translate_name_fn(handle
, name
, direction
, mem_ctx
,
2254 NTSTATUS
smb_vfs_call_fsctl(struct vfs_handle_struct
*handle
,
2255 struct files_struct
*fsp
,
2259 const uint8_t *in_data
,
2262 uint32_t max_out_len
,
2266 return handle
->fns
->fsctl_fn(handle
, fsp
, ctx
, function
, req_flags
,
2267 in_data
, in_len
, out_data
, max_out_len
,
2271 NTSTATUS
smb_vfs_call_get_dos_attributes(struct vfs_handle_struct
*handle
,
2272 struct smb_filename
*smb_fname
,
2275 VFS_FIND(get_dos_attributes
);
2276 return handle
->fns
->get_dos_attributes_fn(handle
, smb_fname
, dosmode
);
2279 NTSTATUS
smb_vfs_call_fget_dos_attributes(struct vfs_handle_struct
*handle
,
2280 struct files_struct
*fsp
,
2283 VFS_FIND(fget_dos_attributes
);
2284 return handle
->fns
->fget_dos_attributes_fn(handle
, fsp
, dosmode
);
2287 NTSTATUS
smb_vfs_call_set_dos_attributes(struct vfs_handle_struct
*handle
,
2288 const struct smb_filename
*smb_fname
,
2291 VFS_FIND(set_dos_attributes
);
2292 return handle
->fns
->set_dos_attributes_fn(handle
, smb_fname
, dosmode
);
2295 NTSTATUS
smb_vfs_call_fset_dos_attributes(struct vfs_handle_struct
*handle
,
2296 struct files_struct
*fsp
,
2299 VFS_FIND(set_dos_attributes
);
2300 return handle
->fns
->fset_dos_attributes_fn(handle
, fsp
, dosmode
);
2303 struct tevent_req
*smb_vfs_call_copy_chunk_send(struct vfs_handle_struct
*handle
,
2304 TALLOC_CTX
*mem_ctx
,
2305 struct tevent_context
*ev
,
2306 struct files_struct
*src_fsp
,
2308 struct files_struct
*dest_fsp
,
2313 VFS_FIND(copy_chunk_send
);
2314 return handle
->fns
->copy_chunk_send_fn(handle
, mem_ctx
, ev
, src_fsp
,
2315 src_off
, dest_fsp
, dest_off
, num
,
2319 NTSTATUS
smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct
*handle
,
2320 struct tevent_req
*req
,
2323 VFS_FIND(copy_chunk_recv
);
2324 return handle
->fns
->copy_chunk_recv_fn(handle
, req
, copied
);
2327 NTSTATUS
smb_vfs_call_get_compression(vfs_handle_struct
*handle
,
2328 TALLOC_CTX
*mem_ctx
,
2329 struct files_struct
*fsp
,
2330 struct smb_filename
*smb_fname
,
2331 uint16_t *_compression_fmt
)
2333 VFS_FIND(get_compression
);
2334 return handle
->fns
->get_compression_fn(handle
, mem_ctx
, fsp
, smb_fname
,
2338 NTSTATUS
smb_vfs_call_set_compression(vfs_handle_struct
*handle
,
2339 TALLOC_CTX
*mem_ctx
,
2340 struct files_struct
*fsp
,
2341 uint16_t compression_fmt
)
2343 VFS_FIND(set_compression
);
2344 return handle
->fns
->set_compression_fn(handle
, mem_ctx
, fsp
,
2348 NTSTATUS
smb_vfs_call_snap_check_path(vfs_handle_struct
*handle
,
2349 TALLOC_CTX
*mem_ctx
,
2350 const char *service_path
,
2353 VFS_FIND(snap_check_path
);
2354 return handle
->fns
->snap_check_path_fn(handle
, mem_ctx
, service_path
,
2358 NTSTATUS
smb_vfs_call_snap_create(struct vfs_handle_struct
*handle
,
2359 TALLOC_CTX
*mem_ctx
,
2360 const char *base_volume
,
2366 VFS_FIND(snap_create
);
2367 return handle
->fns
->snap_create_fn(handle
, mem_ctx
, base_volume
, tstamp
,
2368 rw
, base_path
, snap_path
);
2371 NTSTATUS
smb_vfs_call_snap_delete(struct vfs_handle_struct
*handle
,
2372 TALLOC_CTX
*mem_ctx
,
2376 VFS_FIND(snap_delete
);
2377 return handle
->fns
->snap_delete_fn(handle
, mem_ctx
, base_path
,
2381 NTSTATUS
smb_vfs_call_fget_nt_acl(struct vfs_handle_struct
*handle
,
2382 struct files_struct
*fsp
,
2383 uint32_t security_info
,
2384 TALLOC_CTX
*mem_ctx
,
2385 struct security_descriptor
**ppdesc
)
2387 VFS_FIND(fget_nt_acl
);
2388 return handle
->fns
->fget_nt_acl_fn(handle
, fsp
, security_info
,
2392 NTSTATUS
smb_vfs_call_get_nt_acl(struct vfs_handle_struct
*handle
,
2393 const struct smb_filename
*smb_fname
,
2394 uint32_t security_info
,
2395 TALLOC_CTX
*mem_ctx
,
2396 struct security_descriptor
**ppdesc
)
2398 VFS_FIND(get_nt_acl
);
2399 return handle
->fns
->get_nt_acl_fn(handle
,
2406 NTSTATUS
smb_vfs_call_fset_nt_acl(struct vfs_handle_struct
*handle
,
2407 struct files_struct
*fsp
,
2408 uint32_t security_info_sent
,
2409 const struct security_descriptor
*psd
)
2411 VFS_FIND(fset_nt_acl
);
2412 return handle
->fns
->fset_nt_acl_fn(handle
, fsp
, security_info_sent
,
2416 NTSTATUS
smb_vfs_call_audit_file(struct vfs_handle_struct
*handle
,
2417 struct smb_filename
*file
,
2418 struct security_acl
*sacl
,
2419 uint32_t access_requested
,
2420 uint32_t access_denied
)
2422 VFS_FIND(audit_file
);
2423 return handle
->fns
->audit_file_fn(handle
,
2430 int smb_vfs_call_chmod_acl(struct vfs_handle_struct
*handle
,
2431 const struct smb_filename
*smb_fname
,
2434 VFS_FIND(chmod_acl
);
2435 return handle
->fns
->chmod_acl_fn(handle
, smb_fname
, mode
);
2438 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct
*handle
,
2439 struct files_struct
*fsp
, mode_t mode
)
2441 VFS_FIND(fchmod_acl
);
2442 return handle
->fns
->fchmod_acl_fn(handle
, fsp
, mode
);
2445 SMB_ACL_T
smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct
*handle
,
2446 const struct smb_filename
*smb_fname
,
2447 SMB_ACL_TYPE_T type
,
2448 TALLOC_CTX
*mem_ctx
)
2450 VFS_FIND(sys_acl_get_file
);
2451 return handle
->fns
->sys_acl_get_file_fn(handle
, smb_fname
, type
, mem_ctx
);
2454 SMB_ACL_T
smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct
*handle
,
2455 struct files_struct
*fsp
,
2456 TALLOC_CTX
*mem_ctx
)
2458 VFS_FIND(sys_acl_get_fd
);
2459 return handle
->fns
->sys_acl_get_fd_fn(handle
, fsp
, mem_ctx
);
2462 int smb_vfs_call_sys_acl_blob_get_file(struct vfs_handle_struct
*handle
,
2463 const struct smb_filename
*smb_fname
,
2464 TALLOC_CTX
*mem_ctx
,
2465 char **blob_description
,
2468 VFS_FIND(sys_acl_blob_get_file
);
2469 return handle
->fns
->sys_acl_blob_get_file_fn(handle
, smb_fname
,
2470 mem_ctx
, blob_description
, blob
);
2473 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct
*handle
,
2474 struct files_struct
*fsp
,
2475 TALLOC_CTX
*mem_ctx
,
2476 char **blob_description
,
2479 VFS_FIND(sys_acl_blob_get_fd
);
2480 return handle
->fns
->sys_acl_blob_get_fd_fn(handle
, fsp
, mem_ctx
, blob_description
, blob
);
2483 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct
*handle
,
2484 const struct smb_filename
*smb_fname
,
2485 SMB_ACL_TYPE_T acltype
,
2488 VFS_FIND(sys_acl_set_file
);
2489 return handle
->fns
->sys_acl_set_file_fn(handle
, smb_fname
,
2493 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct
*handle
,
2494 struct files_struct
*fsp
, SMB_ACL_T theacl
)
2496 VFS_FIND(sys_acl_set_fd
);
2497 return handle
->fns
->sys_acl_set_fd_fn(handle
, fsp
, theacl
);
2500 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct
*handle
,
2501 const struct smb_filename
*smb_fname
)
2503 VFS_FIND(sys_acl_delete_def_file
);
2504 return handle
->fns
->sys_acl_delete_def_file_fn(handle
, smb_fname
);
2507 ssize_t
smb_vfs_call_getxattr(struct vfs_handle_struct
*handle
,
2508 const struct smb_filename
*smb_fname
,
2514 return handle
->fns
->getxattr_fn(handle
, smb_fname
, name
, value
, size
);
2517 ssize_t
smb_vfs_call_fgetxattr(struct vfs_handle_struct
*handle
,
2518 struct files_struct
*fsp
, const char *name
,
2519 void *value
, size_t size
)
2521 VFS_FIND(fgetxattr
);
2522 return handle
->fns
->fgetxattr_fn(handle
, fsp
, name
, value
, size
);
2525 ssize_t
smb_vfs_call_listxattr(struct vfs_handle_struct
*handle
,
2526 const struct smb_filename
*smb_fname
,
2530 VFS_FIND(listxattr
);
2531 return handle
->fns
->listxattr_fn(handle
, smb_fname
, list
, size
);
2534 ssize_t
smb_vfs_call_flistxattr(struct vfs_handle_struct
*handle
,
2535 struct files_struct
*fsp
, char *list
,
2538 VFS_FIND(flistxattr
);
2539 return handle
->fns
->flistxattr_fn(handle
, fsp
, list
, size
);
2542 int smb_vfs_call_removexattr(struct vfs_handle_struct
*handle
,
2543 const struct smb_filename
*smb_fname
,
2546 VFS_FIND(removexattr
);
2547 return handle
->fns
->removexattr_fn(handle
, smb_fname
, name
);
2550 int smb_vfs_call_fremovexattr(struct vfs_handle_struct
*handle
,
2551 struct files_struct
*fsp
, const char *name
)
2553 VFS_FIND(fremovexattr
);
2554 return handle
->fns
->fremovexattr_fn(handle
, fsp
, name
);
2557 int smb_vfs_call_setxattr(struct vfs_handle_struct
*handle
,
2558 const struct smb_filename
*smb_fname
,
2565 return handle
->fns
->setxattr_fn(handle
, smb_fname
,
2566 name
, value
, size
, flags
);
2569 int smb_vfs_call_fsetxattr(struct vfs_handle_struct
*handle
,
2570 struct files_struct
*fsp
, const char *name
,
2571 const void *value
, size_t size
, int flags
)
2573 VFS_FIND(fsetxattr
);
2574 return handle
->fns
->fsetxattr_fn(handle
, fsp
, name
, value
, size
, flags
);
2577 bool smb_vfs_call_aio_force(struct vfs_handle_struct
*handle
,
2578 struct files_struct
*fsp
)
2580 VFS_FIND(aio_force
);
2581 return handle
->fns
->aio_force_fn(handle
, fsp
);
2584 NTSTATUS
smb_vfs_call_durable_cookie(struct vfs_handle_struct
*handle
,
2585 struct files_struct
*fsp
,
2586 TALLOC_CTX
*mem_ctx
,
2589 VFS_FIND(durable_cookie
);
2590 return handle
->fns
->durable_cookie_fn(handle
, fsp
, mem_ctx
, cookie
);
2593 NTSTATUS
smb_vfs_call_durable_disconnect(struct vfs_handle_struct
*handle
,
2594 struct files_struct
*fsp
,
2595 const DATA_BLOB old_cookie
,
2596 TALLOC_CTX
*mem_ctx
,
2597 DATA_BLOB
*new_cookie
)
2599 VFS_FIND(durable_disconnect
);
2600 return handle
->fns
->durable_disconnect_fn(handle
, fsp
, old_cookie
,
2601 mem_ctx
, new_cookie
);
2604 NTSTATUS
smb_vfs_call_durable_reconnect(struct vfs_handle_struct
*handle
,
2605 struct smb_request
*smb1req
,
2606 struct smbXsrv_open
*op
,
2607 const DATA_BLOB old_cookie
,
2608 TALLOC_CTX
*mem_ctx
,
2609 struct files_struct
**fsp
,
2610 DATA_BLOB
*new_cookie
)
2612 VFS_FIND(durable_reconnect
);
2613 return handle
->fns
->durable_reconnect_fn(handle
, smb1req
, op
,
2614 old_cookie
, mem_ctx
, fsp
,
2618 NTSTATUS
smb_vfs_call_readdir_attr(struct vfs_handle_struct
*handle
,
2619 const struct smb_filename
*fname
,
2620 TALLOC_CTX
*mem_ctx
,
2621 struct readdir_attr_data
**attr_data
)
2623 VFS_FIND(readdir_attr
);
2624 return handle
->fns
->readdir_attr_fn(handle
, fname
, mem_ctx
, attr_data
);