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"
34 #include "lib/util/tevent_ntstatus.h"
35 #include "lib/util/sys_rw.h"
38 #define DBGC_CLASS DBGC_VFS
43 struct vfs_fsp_data
*next
;
44 struct vfs_handle_struct
*owner
;
45 void (*destroy
)(void *p_data
);
47 /* NOTE: This structure contains four pointers so that we can guarantee
48 * that the end of the structure is always both 4-byte and 8-byte aligned.
52 struct vfs_init_function_entry
{
54 struct vfs_init_function_entry
*prev
, *next
;
55 const struct vfs_fn_pointers
*fns
;
58 /****************************************************************************
59 maintain the list of available backends
60 ****************************************************************************/
62 static struct vfs_init_function_entry
*vfs_find_backend_entry(const char *name
)
64 struct vfs_init_function_entry
*entry
= backends
;
66 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name
));
69 if (strcmp(entry
->name
, name
)==0) return entry
;
76 NTSTATUS
smb_register_vfs(int version
, const char *name
,
77 const struct vfs_fn_pointers
*fns
)
79 struct vfs_init_function_entry
*entry
= backends
;
81 if ((version
!= SMB_VFS_INTERFACE_VERSION
)) {
82 DEBUG(0, ("Failed to register vfs module.\n"
83 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
84 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
85 "Please recompile against the current Samba Version!\n",
86 version
, SMB_VFS_INTERFACE_VERSION
));
87 return NT_STATUS_OBJECT_TYPE_MISMATCH
;
90 if (!name
|| !name
[0]) {
91 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
92 return NT_STATUS_INVALID_PARAMETER
;
95 if (vfs_find_backend_entry(name
)) {
96 DEBUG(0,("VFS module %s already loaded!\n", name
));
97 return NT_STATUS_OBJECT_NAME_COLLISION
;
100 entry
= SMB_XMALLOC_P(struct vfs_init_function_entry
);
101 entry
->name
= smb_xstrdup(name
);
104 DLIST_ADD(backends
, entry
);
105 DEBUG(5, ("Successfully added vfs backend '%s'\n", name
));
109 /****************************************************************************
110 initialise default vfs hooks
111 ****************************************************************************/
113 static void vfs_init_default(connection_struct
*conn
)
115 DEBUG(3, ("Initialising default vfs hooks\n"));
116 vfs_init_custom(conn
, DEFAULT_VFS_MODULE_NAME
);
119 /****************************************************************************
120 initialise custom vfs hooks
121 ****************************************************************************/
123 bool vfs_init_custom(connection_struct
*conn
, const char *vfs_object
)
125 char *module_path
= NULL
;
126 char *module_name
= NULL
;
127 char *module_param
= NULL
, *p
;
128 vfs_handle_struct
*handle
;
129 const struct vfs_init_function_entry
*entry
;
131 if (!conn
||!vfs_object
||!vfs_object
[0]) {
132 DEBUG(0, ("vfs_init_custom() called with NULL pointer or "
133 "empty vfs_object!\n"));
138 static_init_vfs(NULL
);
141 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object
));
143 module_path
= smb_xstrdup(vfs_object
);
145 p
= strchr_m(module_path
, ':');
150 trim_char(module_param
, ' ', ' ');
153 trim_char(module_path
, ' ', ' ');
155 module_name
= smb_xstrdup(module_path
);
157 if ((module_name
[0] == '/') &&
158 (strcmp(module_path
, DEFAULT_VFS_MODULE_NAME
) != 0)) {
161 * Extract the module name from the path. Just use the base
162 * name of the last path component.
165 SAFE_FREE(module_name
);
166 module_name
= smb_xstrdup(strrchr_m(module_path
, '/')+1);
168 p
= strchr_m(module_name
, '.');
175 /* First, try to load the module with the new module system */
176 entry
= vfs_find_backend_entry(module_name
);
180 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
183 status
= smb_load_module("vfs", module_path
);
184 if (!NT_STATUS_IS_OK(status
)) {
185 DEBUG(0, ("error probing vfs module '%s': %s\n",
186 module_path
, nt_errstr(status
)));
190 entry
= vfs_find_backend_entry(module_name
);
192 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object
));
197 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object
));
199 handle
= talloc_zero(conn
, vfs_handle_struct
);
201 DEBUG(0,("TALLOC_ZERO() failed!\n"));
205 handle
->fns
= entry
->fns
;
207 handle
->param
= talloc_strdup(conn
, module_param
);
209 DLIST_ADD(conn
->vfs_handles
, handle
);
211 SAFE_FREE(module_path
);
212 SAFE_FREE(module_name
);
216 SAFE_FREE(module_path
);
217 SAFE_FREE(module_name
);
221 /*****************************************************************
222 Allow VFS modules to extend files_struct with VFS-specific state.
223 This will be ok for small numbers of extensions, but might need to
224 be refactored if it becomes more widely used.
225 ******************************************************************/
227 #define EXT_DATA_AREA(e) ((uint8_t *)(e) + sizeof(struct vfs_fsp_data))
229 void *vfs_add_fsp_extension_notype(vfs_handle_struct
*handle
,
230 files_struct
*fsp
, size_t ext_size
,
231 void (*destroy_fn
)(void *p_data
))
233 struct vfs_fsp_data
*ext
;
236 /* Prevent VFS modules adding multiple extensions. */
237 if ((ext_data
= vfs_fetch_fsp_extension(handle
, fsp
))) {
241 ext
= talloc_zero_size(
242 handle
->conn
, sizeof(struct vfs_fsp_data
) + ext_size
);
248 ext
->next
= fsp
->vfs_extension
;
249 ext
->destroy
= destroy_fn
;
250 fsp
->vfs_extension
= ext
;
251 return EXT_DATA_AREA(ext
);
254 void vfs_remove_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
256 struct vfs_fsp_data
*curr
;
257 struct vfs_fsp_data
*prev
;
259 for (curr
= fsp
->vfs_extension
, prev
= NULL
;
261 prev
= curr
, curr
= curr
->next
) {
262 if (curr
->owner
== handle
) {
264 prev
->next
= curr
->next
;
266 fsp
->vfs_extension
= curr
->next
;
269 curr
->destroy(EXT_DATA_AREA(curr
));
277 void vfs_remove_all_fsp_extensions(files_struct
*fsp
)
279 struct vfs_fsp_data
*curr
;
280 struct vfs_fsp_data
*next
;
282 for (curr
= fsp
->vfs_extension
; curr
; curr
= next
) {
285 fsp
->vfs_extension
= next
;
288 curr
->destroy(EXT_DATA_AREA(curr
));
294 void *vfs_memctx_fsp_extension(vfs_handle_struct
*handle
,
295 const struct files_struct
*fsp
)
297 struct vfs_fsp_data
*head
;
299 for (head
= fsp
->vfs_extension
; head
; head
= head
->next
) {
300 if (head
->owner
== handle
) {
308 void *vfs_fetch_fsp_extension(vfs_handle_struct
*handle
,
309 const struct files_struct
*fsp
)
311 struct vfs_fsp_data
*head
;
313 head
= (struct vfs_fsp_data
*)vfs_memctx_fsp_extension(handle
, fsp
);
315 return EXT_DATA_AREA(head
);
324 * Ensure this module catches all VFS functions.
327 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers
* fns
,
330 bool missing_fn
= false;
332 const uintptr_t *end
= (const uintptr_t *)(fns
+ 1);
334 for (idx
= 0; ((const uintptr_t *)fns
+ idx
) < end
; idx
++) {
335 if (*((const uintptr_t *)fns
+ idx
) == 0) {
336 DBG_ERR("VFS function at index %d not implemented "
337 "in module %s\n", idx
, module
);
343 smb_panic("Required VFS function not implemented in module.\n");
347 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers
* fns
,
353 /*****************************************************************
355 ******************************************************************/
357 bool smbd_vfs_init(connection_struct
*conn
)
359 const char **vfs_objects
;
363 /* Normal share - initialise with disk access functions */
364 vfs_init_default(conn
);
366 /* No need to load vfs modules for printer connections */
371 if (lp_widelinks(SNUM(conn
))) {
373 * As the widelinks logic is now moving into a
374 * vfs_widelinks module, we need to custom load
375 * it after the default module is initialized.
376 * That way no changes to smb.conf files are
379 bool ok
= vfs_init_custom(conn
, "widelinks");
381 DBG_ERR("widelinks enabled and vfs_init_custom "
382 "failed for vfs_widelinks module\n");
387 vfs_objects
= lp_vfs_objects(SNUM(conn
));
389 /* Override VFS functions if 'vfs object' was not specified*/
390 if (!vfs_objects
|| !vfs_objects
[0])
393 for (i
=0; vfs_objects
[i
] ;) {
397 for (j
=i
-1; j
>= 0; j
--) {
398 if (!vfs_init_custom(conn
, vfs_objects
[j
])) {
399 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects
[j
]));
406 /*******************************************************************
407 Check if a file exists in the vfs.
408 ********************************************************************/
410 NTSTATUS
vfs_file_exist(connection_struct
*conn
, struct smb_filename
*smb_fname
)
412 /* Only return OK if stat was successful and S_ISREG */
413 if ((SMB_VFS_STAT(conn
, smb_fname
) != -1) &&
414 S_ISREG(smb_fname
->st
.st_ex_mode
)) {
418 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
421 bool vfs_valid_pread_range(off_t offset
, size_t length
)
423 return sys_valid_io_range(offset
, length
);
426 bool vfs_valid_pwrite_range(off_t offset
, size_t length
)
429 * See MAXFILESIZE in [MS-FSA] 2.1.5.3 Server Requests a Write
431 static const uint64_t maxfilesize
= 0xfffffff0000;
432 uint64_t last_byte_ofs
;
435 ok
= sys_valid_io_range(offset
, length
);
444 last_byte_ofs
= offset
+ length
;
445 if (last_byte_ofs
> maxfilesize
) {
452 ssize_t
vfs_pwrite_data(struct smb_request
*req
,
462 ok
= vfs_valid_pwrite_range(offset
, N
);
468 if (req
&& req
->unread_bytes
) {
469 int sockfd
= req
->xconn
->transport
.sock
;
470 SMB_ASSERT(req
->unread_bytes
== N
);
471 /* VFS_RECVFILE must drain the socket
472 * before returning. */
473 req
->unread_bytes
= 0;
475 * Leave the socket non-blocking and
476 * use SMB_VFS_RECVFILE. If it returns
477 * EAGAIN || EWOULDBLOCK temporarily set
478 * the socket blocking and retry
482 ret
= SMB_VFS_RECVFILE(sockfd
,
486 if (ret
== 0 || (ret
== -1 &&
488 errno
== EWOULDBLOCK
))) {
490 /* Ensure the socket is blocking. */
491 old_flags
= fcntl(sockfd
, F_GETFL
, 0);
492 if (set_blocking(sockfd
, true) == -1) {
495 ret
= SMB_VFS_RECVFILE(sockfd
,
499 if (fcntl(sockfd
, F_SETFL
, old_flags
) == -1) {
506 return (ssize_t
)total
;
508 /* Any other error case. */
514 return (ssize_t
)total
;
518 ret
= SMB_VFS_PWRITE(fsp
, buffer
+ total
, N
- total
,
528 return (ssize_t
)total
;
530 /****************************************************************************
531 An allocate file space call using the vfs interface.
532 Allocates space for a file from a filedescriptor.
533 Returns 0 on success, -1 on failure.
534 ****************************************************************************/
536 int vfs_allocate_file_space(files_struct
*fsp
, uint64_t len
)
539 connection_struct
*conn
= fsp
->conn
;
540 uint64_t space_avail
;
541 uint64_t bsize
,dfree
,dsize
;
546 * Actually try and commit the space on disk....
549 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
550 fsp_str_dbg(fsp
), (double)len
));
552 ok
= vfs_valid_pwrite_range((off_t
)len
, 0);
554 DEBUG(0,("vfs_allocate_file_space: %s negative/invalid len "
555 "requested.\n", fsp_str_dbg(fsp
)));
560 status
= vfs_stat_fsp(fsp
);
561 if (!NT_STATUS_IS_OK(status
)) {
565 if (len
== (uint64_t)fsp
->fsp_name
->st
.st_ex_size
)
568 if (len
< (uint64_t)fsp
->fsp_name
->st
.st_ex_size
) {
569 /* Shrink - use ftruncate. */
571 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current "
572 "size %.0f\n", fsp_str_dbg(fsp
),
573 (double)fsp
->fsp_name
->st
.st_ex_size
));
575 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
577 ret
= SMB_VFS_FTRUNCATE(fsp
, (off_t
)len
);
579 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
584 /* Grow - we need to test if we have enough space. */
586 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
588 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
589 /* See if we have a syscall that will allocate beyond
590 end-of-file without changing EOF. */
591 ret
= SMB_VFS_FALLOCATE(fsp
, VFS_FALLOCATE_FL_KEEP_SIZE
,
597 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
600 /* We changed the allocation size on disk, but not
601 EOF - exactly as required. We're done ! */
605 if (ret
== -1 && errno
== ENOSPC
) {
609 len
-= fsp
->fsp_name
->st
.st_ex_size
;
610 len
/= 1024; /* Len is now number of 1k blocks needed. */
612 get_dfree_info(conn
, fsp
->fsp_name
, &bsize
, &dfree
, &dsize
);
613 if (space_avail
== (uint64_t)-1) {
617 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
618 "needed blocks = %.0f, space avail = %.0f\n",
619 fsp_str_dbg(fsp
), (double)fsp
->fsp_name
->st
.st_ex_size
, (double)len
,
620 (double)space_avail
));
622 if (len
> space_avail
) {
630 /****************************************************************************
631 A vfs set_filelen call.
632 set the length of a file from a filedescriptor.
633 Returns 0 on success, -1 on failure.
634 ****************************************************************************/
636 int vfs_set_filelen(files_struct
*fsp
, off_t len
)
641 ok
= vfs_valid_pwrite_range(len
, 0);
647 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
649 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
650 fsp_str_dbg(fsp
), (double)len
));
651 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, len
)) != -1) {
652 notify_fname(fsp
->conn
, NOTIFY_ACTION_MODIFIED
,
653 FILE_NOTIFY_CHANGE_SIZE
654 | FILE_NOTIFY_CHANGE_ATTRIBUTES
,
655 fsp
->fsp_name
->base_name
);
658 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
663 /****************************************************************************
664 A slow version of fallocate. Fallback code if SMB_VFS_FALLOCATE
665 fails. Needs to be outside of the default version of SMB_VFS_FALLOCATE
666 as this is also called from the default SMB_VFS_FTRUNCATE code.
667 Always extends the file size.
668 Returns 0 on success, -1 on failure.
669 ****************************************************************************/
671 #define SPARSE_BUF_WRITE_SIZE (32*1024)
673 int vfs_slow_fallocate(files_struct
*fsp
, off_t offset
, off_t len
)
679 ok
= vfs_valid_pwrite_range(offset
, len
);
686 sparse_buf
= SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE
);
693 while (total
< len
) {
694 size_t curr_write_size
= MIN(SPARSE_BUF_WRITE_SIZE
, (len
- total
));
696 pwrite_ret
= SMB_VFS_PWRITE(fsp
, sparse_buf
, curr_write_size
, offset
+ total
);
697 if (pwrite_ret
== -1) {
698 int saved_errno
= errno
;
699 DEBUG(10,("vfs_slow_fallocate: SMB_VFS_PWRITE for file "
700 "%s failed with error %s\n",
701 fsp_str_dbg(fsp
), strerror(saved_errno
)));
711 /****************************************************************************
712 A vfs fill sparse call.
713 Writes zeros from the end of file to len, if len is greater than EOF.
714 Used only by strict_sync.
715 Returns 0 on success, -1 on failure.
716 ****************************************************************************/
718 int vfs_fill_sparse(files_struct
*fsp
, off_t len
)
726 ok
= vfs_valid_pwrite_range(len
, 0);
732 status
= vfs_stat_fsp(fsp
);
733 if (!NT_STATUS_IS_OK(status
)) {
737 if (len
<= fsp
->fsp_name
->st
.st_ex_size
) {
742 if (S_ISFIFO(fsp
->fsp_name
->st
.st_ex_mode
)) {
747 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
748 "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp
),
749 (double)fsp
->fsp_name
->st
.st_ex_size
, (double)len
,
750 (double)(len
- fsp
->fsp_name
->st
.st_ex_size
)));
752 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
754 offset
= fsp
->fsp_name
->st
.st_ex_size
;
755 num_to_write
= len
- fsp
->fsp_name
->st
.st_ex_size
;
757 /* Only do this on non-stream file handles. */
758 if (!fsp_is_alternate_stream(fsp
)) {
759 /* for allocation try fallocate first. This can fail on some
760 * platforms e.g. when the filesystem doesn't support it and no
761 * emulation is being done by the libc (like on AIX with JFS1). In that
762 * case we do our own emulation. fallocate implementations can
763 * return ENOTSUP or EINVAL in cases like that. */
764 ret
= SMB_VFS_FALLOCATE(fsp
, 0, offset
, num_to_write
);
765 if (ret
== -1 && errno
== ENOSPC
) {
771 DEBUG(10,("vfs_fill_sparse: SMB_VFS_FALLOCATE failed with "
772 "error %d. Falling back to slow manual allocation\n", ret
));
775 ret
= vfs_slow_fallocate(fsp
, offset
, num_to_write
);
779 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
783 /*******************************************************************************
784 Set a fd into blocking/nonblocking mode through VFS
785 *******************************************************************************/
787 int vfs_set_blocking(files_struct
*fsp
, bool set
)
791 #define FLAG_TO_SET O_NONBLOCK
794 #define FLAG_TO_SET O_NDELAY
796 #define FLAG_TO_SET FNDELAY
800 if (fsp
->fsp_flags
.is_pathref
) {
804 val
= SMB_VFS_FCNTL(fsp
, F_GETFL
, 0);
815 return SMB_VFS_FCNTL(fsp
, F_SETFL
, val
);
819 /****************************************************************************
820 Transfer some data (n bytes) between two file_struct's.
821 ****************************************************************************/
823 static ssize_t
vfs_pread_fn(void *file
, void *buf
, size_t len
, off_t offset
)
825 struct files_struct
*fsp
= (struct files_struct
*)file
;
827 return SMB_VFS_PREAD(fsp
, buf
, len
, offset
);
830 static ssize_t
vfs_pwrite_fn(void *file
, const void *buf
, size_t len
, off_t offset
)
832 struct files_struct
*fsp
= (struct files_struct
*)file
;
834 return SMB_VFS_PWRITE(fsp
, buf
, len
, offset
);
837 off_t
vfs_transfer_file(files_struct
*in
, files_struct
*out
, off_t n
)
839 return transfer_file_internal((void *)in
, (void *)out
, n
,
840 vfs_pread_fn
, vfs_pwrite_fn
);
843 /*******************************************************************
844 A vfs_readdir wrapper which just returns the file name.
845 ********************************************************************/
847 const char *vfs_readdirname(connection_struct
*conn
,
848 struct files_struct
*dirfsp
,
850 SMB_STRUCT_STAT
*sbuf
,
853 struct dirent
*ptr
= NULL
;
861 ptr
= SMB_VFS_READDIR(conn
, dirfsp
, (DIR *)p
, sbuf
);
867 status
= SMB_VFS_TRANSLATE_NAME(conn
, dname
, vfs_translate_to_windows
,
868 talloc_tos(), &translated
);
869 if (NT_STATUS_EQUAL(status
, NT_STATUS_NONE_MAPPED
)) {
873 *talloced
= translated
;
874 if (!NT_STATUS_IS_OK(status
)) {
880 /*******************************************************************
881 A wrapper for vfs_chdir().
882 ********************************************************************/
884 int vfs_ChDir(connection_struct
*conn
, const struct smb_filename
*smb_fname
)
887 struct smb_filename
*cwd
= NULL
;
890 LastDir
= SMB_STRDUP("");
893 if (ISDOT(smb_fname
->base_name
)) {
895 * passing a '.' is a noop,
896 * and we only expect this after
897 * everything is initialized.
899 * So the first vfs_ChDir() on a given
900 * connection_struct must not be '.'.
902 * Note: conn_new() sets
903 * conn->cwd_fsp->fh->fd = -1
904 * and vfs_ChDir() leaves with
905 * conn->cwd_fsp->fh->fd = AT_FDCWD
908 if (fsp_get_pathref_fd(conn
->cwd_fsp
) != AT_FDCWD
) {
910 * This should never happen and
911 * we might change this to
912 * SMB_ASSERT() in future.
914 DBG_ERR("Called with '.' as first operation!\n");
922 if (smb_fname
->base_name
[0] == '/' &&
923 strcsequal(LastDir
,smb_fname
->base_name
))
926 * conn->cwd_fsp->fsp_name and the kernel
927 * are already correct, but conn->cwd_fsp->fh->fd
928 * might still be -1 as initialized in conn_new().
930 * This can happen when a client made a 2nd
931 * tree connect to a share with the same underlying
932 * path (may or may not the same share).
934 fsp_set_fd(conn
->cwd_fsp
, AT_FDCWD
);
938 DEBUG(4,("vfs_ChDir to %s\n", smb_fname
->base_name
));
940 ret
= SMB_VFS_CHDIR(conn
, smb_fname
);
946 * Always replace conn->cwd_fsp. We
947 * don't know if it's been modified by
948 * VFS modules in the stack.
950 fsp_set_fd(conn
->cwd_fsp
, AT_FDCWD
);
953 cwd
= vfs_GetWd(conn
, conn
);
956 * vfs_GetWd() failed.
957 * We must be able to read cwd.
958 * Return to original directory
961 int saved_errno
= errno
;
963 if (conn
->cwd_fsp
->fsp_name
== NULL
) {
965 * Failed on the very first chdir()+getwd()
966 * for this connection. We can't
969 smb_panic("conn->cwd getwd failed\n");
974 /* Return to the previous $cwd. */
975 ret
= SMB_VFS_CHDIR(conn
, conn
->cwd_fsp
->fsp_name
);
977 smb_panic("conn->cwd getwd failed\n");
982 /* And fail the chdir(). */
986 /* vfs_GetWd() succeeded. */
987 /* Replace global cache. */
989 LastDir
= SMB_STRDUP(smb_fname
->base_name
);
992 * (Indirect) Callers of vfs_ChDir() may still hold references to the
993 * old conn->cwd_fsp->fsp_name. Move it to talloc_tos(), that way
994 * callers can use it for the lifetime of the SMB request.
996 talloc_move(talloc_tos(), &conn
->cwd_fsp
->fsp_name
);
998 conn
->cwd_fsp
->fsp_name
= talloc_move(conn
->cwd_fsp
, &cwd
);
1000 DBG_INFO("vfs_ChDir got %s\n", fsp_str_dbg(conn
->cwd_fsp
));
1005 /*******************************************************************
1006 Return the absolute current directory path - given a UNIX pathname.
1007 Note that this path is returned in DOS format, not UNIX
1008 format. Note this can be called with conn == NULL.
1009 ********************************************************************/
1011 struct smb_filename
*vfs_GetWd(TALLOC_CTX
*ctx
, connection_struct
*conn
)
1013 struct smb_filename
*current_dir_fname
= NULL
;
1015 struct smb_filename
*smb_fname_dot
= NULL
;
1016 struct smb_filename
*smb_fname_full
= NULL
;
1017 struct smb_filename
*result
= NULL
;
1019 if (!lp_getwd_cache()) {
1023 smb_fname_dot
= synthetic_smb_fname(ctx
,
1029 if (smb_fname_dot
== NULL
) {
1034 if (SMB_VFS_STAT(conn
, smb_fname_dot
) == -1) {
1036 * Known to fail for root: the directory may be NFS-mounted
1037 * and exported with root_squash (so has no root access).
1039 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
1040 "(NFS problem ?)\n", strerror(errno
) ));
1044 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
1046 smb_fname_full
= (struct smb_filename
*)memcache_lookup_talloc(
1049 data_blob_const(&key
, sizeof(key
)));
1051 if (smb_fname_full
== NULL
) {
1055 if ((SMB_VFS_STAT(conn
, smb_fname_full
) == 0) &&
1056 (smb_fname_dot
->st
.st_ex_dev
== smb_fname_full
->st
.st_ex_dev
) &&
1057 (smb_fname_dot
->st
.st_ex_ino
== smb_fname_full
->st
.st_ex_ino
) &&
1058 (S_ISDIR(smb_fname_dot
->st
.st_ex_mode
))) {
1061 * Note: smb_fname_full is owned by smbd_memcache()
1062 * so we must make a copy to return.
1064 result
= cp_smb_filename(ctx
, smb_fname_full
);
1065 if (result
== NULL
) {
1074 * We don't have the information to hand so rely on traditional
1075 * methods. The very slow getcwd, which spawns a process on some
1076 * systems, or the not quite so bad getwd.
1079 current_dir_fname
= SMB_VFS_GETWD(conn
, ctx
);
1080 if (current_dir_fname
== NULL
) {
1081 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
1086 if (lp_getwd_cache() && VALID_STAT(smb_fname_dot
->st
)) {
1087 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
1090 * smbd_memcache() will own current_dir_fname after the
1091 * memcache_add_talloc call, so we must make
1092 * a copy on ctx to return.
1094 result
= cp_smb_filename(ctx
, current_dir_fname
);
1095 if (result
== NULL
) {
1100 * Ensure the memory going into the cache
1101 * doesn't have a destructor so it can be
1104 talloc_set_destructor(current_dir_fname
, NULL
);
1106 memcache_add_talloc(smbd_memcache(),
1108 data_blob_const(&key
, sizeof(key
)),
1109 ¤t_dir_fname
);
1110 /* current_dir_fname is now == NULL here. */
1112 /* current_dir_fname is already allocated on ctx. */
1113 result
= current_dir_fname
;
1117 TALLOC_FREE(smb_fname_dot
);
1119 * Don't free current_dir_fname here. It's either been moved
1120 * to the memcache or is being returned in result.
1125 /*******************************************************************
1126 Reduce a file name, removing .. elements and checking that
1127 it is below dir in the hierarchy. This uses realpath.
1129 If cwd_name == NULL then fname is a client given path relative
1130 to the root path of the share.
1132 If cwd_name != NULL then fname is a client given path relative
1133 to cwd_name. cwd_name is relative to the root path of the share.
1134 ********************************************************************/
1136 NTSTATUS
check_reduced_name(connection_struct
*conn
,
1137 const struct smb_filename
*cwd_fname
,
1138 const struct smb_filename
*smb_fname
)
1140 TALLOC_CTX
*ctx
= talloc_tos();
1141 const char *cwd_name
= cwd_fname
? cwd_fname
->base_name
: NULL
;
1142 const char *fname
= smb_fname
->base_name
;
1143 struct smb_filename
*resolved_fname
;
1144 char *resolved_name
= NULL
;
1145 char *new_fname
= NULL
;
1146 bool allow_symlinks
= true;
1147 const char *conn_rootdir
;
1149 bool parent_dir_checked
= false;
1151 DBG_DEBUG("check_reduced_name [%s] [%s]\n", fname
, conn
->connectpath
);
1153 resolved_fname
= SMB_VFS_REALPATH(conn
, ctx
, smb_fname
);
1155 if (resolved_fname
== NULL
) {
1157 struct smb_filename
*dir_fname
= NULL
;
1158 struct smb_filename
*last_component
= NULL
;
1160 if (errno
== ENOTDIR
) {
1161 DBG_NOTICE("Component not a directory in getting "
1162 "realpath for %s\n",
1164 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1166 if (errno
!= ENOENT
) {
1167 status
= map_nt_error_from_unix(errno
);
1168 DBG_NOTICE("couldn't get realpath for %s: %s\n",
1174 /* errno == ENOENT */
1177 * Last component didn't exist. Remove it and try and
1178 * canonicalise the directory name.
1181 status
= SMB_VFS_PARENT_PATHNAME(conn
,
1186 if (!NT_STATUS_IS_OK(status
)) {
1190 resolved_fname
= SMB_VFS_REALPATH(conn
, ctx
, dir_fname
);
1191 if (resolved_fname
== NULL
) {
1192 status
= map_nt_error_from_unix(errno
);
1194 if (errno
== ENOENT
|| errno
== ENOTDIR
) {
1195 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1198 DBG_NOTICE("couldn't get realpath for "
1200 smb_fname_str_dbg(dir_fname
),
1204 resolved_name
= talloc_asprintf(ctx
,
1206 resolved_fname
->base_name
,
1207 last_component
->base_name
);
1208 if (resolved_name
== NULL
) {
1209 return NT_STATUS_NO_MEMORY
;
1211 parent_dir_checked
= true;
1213 resolved_name
= resolved_fname
->base_name
;
1216 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname
,
1219 if (*resolved_name
!= '/') {
1220 DEBUG(0,("check_reduced_name: realpath doesn't return "
1221 "absolute paths !\n"));
1222 TALLOC_FREE(resolved_fname
);
1223 return NT_STATUS_OBJECT_NAME_INVALID
;
1226 /* Common widelinks and symlinks checks. */
1227 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, smb_fname
);
1228 if (conn_rootdir
== NULL
) {
1229 DBG_NOTICE("Could not get conn_rootdir\n");
1230 TALLOC_FREE(resolved_fname
);
1231 return NT_STATUS_ACCESS_DENIED
;
1234 rootdir_len
= strlen(conn_rootdir
);
1237 * In the case of rootdir_len == 1, we know that
1238 * conn_rootdir is "/", and we also know that
1239 * resolved_name starts with a slash. So, in this
1240 * corner case, resolved_name is automatically a
1241 * sub-directory of the conn_rootdir. Thus we can skip
1242 * the string comparison and the next character checks
1243 * (which are even wrong in this case).
1245 if (rootdir_len
!= 1) {
1248 matched
= (strncmp(conn_rootdir
, resolved_name
,
1250 if (!matched
|| (resolved_name
[rootdir_len
] != '/' &&
1251 resolved_name
[rootdir_len
] != '\0')) {
1252 DBG_NOTICE("Bad access attempt: %s is a symlink "
1255 "conn_rootdir =%s\n"
1256 "resolved_name=%s\n",
1260 TALLOC_FREE(resolved_fname
);
1261 if (parent_dir_checked
) {
1262 /* Part of a component path. */
1263 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1265 /* End of a path. */
1266 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1271 /* Extra checks if all symlinks are disallowed. */
1272 allow_symlinks
= lp_follow_symlinks(SNUM(conn
));
1273 if (!allow_symlinks
) {
1274 /* fname can't have changed in resolved_path. */
1275 const char *p
= &resolved_name
[rootdir_len
];
1278 * UNIX filesystem semantics, names consisting
1279 * only of "." or ".." CANNOT be symlinks.
1281 if (ISDOT(fname
) || ISDOTDOT(fname
)) {
1286 DBG_NOTICE("logic error (%c) "
1287 "in resolved_name: %s\n",
1290 TALLOC_FREE(resolved_fname
);
1291 return NT_STATUS_ACCESS_DENIED
;
1297 * If cwd_name is present and not ".",
1298 * then fname is relative to that, not
1299 * the root of the share. Make sure the
1300 * path we check is the one the client
1301 * sent (cwd_name+fname).
1303 if (cwd_name
!= NULL
&& !ISDOT(cwd_name
)) {
1304 new_fname
= talloc_asprintf(ctx
,
1308 if (new_fname
== NULL
) {
1309 TALLOC_FREE(resolved_fname
);
1310 return NT_STATUS_NO_MEMORY
;
1315 if (strcmp(fname
, p
)!=0) {
1316 DBG_NOTICE("Bad access "
1317 "attempt: %s is a symlink to %s\n",
1320 TALLOC_FREE(resolved_fname
);
1321 TALLOC_FREE(new_fname
);
1322 if (parent_dir_checked
) {
1323 /* Part of a component path. */
1324 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1326 /* End of a path. */
1327 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1334 DBG_INFO("%s reduced to %s\n", fname
, resolved_name
);
1335 TALLOC_FREE(resolved_fname
);
1336 TALLOC_FREE(new_fname
);
1337 return NT_STATUS_OK
;
1341 * Ensure LSTAT is called for POSIX paths.
1343 int vfs_stat(struct connection_struct
*conn
,
1344 struct smb_filename
*smb_fname
)
1346 if (smb_fname
->flags
& SMB_FILENAME_POSIX_PATH
) {
1347 return SMB_VFS_LSTAT(conn
, smb_fname
);
1349 return SMB_VFS_STAT(conn
, smb_fname
);
1353 * XXX: This is temporary and there should be no callers of this once
1354 * smb_filename is plumbed through all path based operations.
1356 * Called when we know stream name parsing has already been done.
1358 int vfs_stat_smb_basename(struct connection_struct
*conn
,
1359 const struct smb_filename
*smb_fname_in
,
1360 SMB_STRUCT_STAT
*psbuf
)
1362 struct smb_filename smb_fname
= {
1363 .base_name
= discard_const_p(char, smb_fname_in
->base_name
),
1364 .flags
= smb_fname_in
->flags
,
1365 .twrp
= smb_fname_in
->twrp
,
1369 ret
= vfs_stat(conn
, &smb_fname
);
1371 *psbuf
= smb_fname
.st
;
1377 * Ensure LSTAT is called for POSIX paths.
1380 NTSTATUS
vfs_stat_fsp(files_struct
*fsp
)
1383 struct stat_ex saved_stat
= fsp
->fsp_name
->st
;
1385 if (fsp_get_pathref_fd(fsp
) == -1) {
1386 if (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) {
1387 ret
= SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1389 ret
= SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1392 ret
= SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
);
1395 return map_nt_error_from_unix(errno
);
1397 update_stat_ex_from_saved_stat(&fsp
->fsp_name
->st
, &saved_stat
);
1398 fsp
->fsp_flags
.is_directory
= S_ISDIR(fsp
->fsp_name
->st
.st_ex_mode
);
1399 return NT_STATUS_OK
;
1402 void init_smb_file_time(struct smb_file_time
*ft
)
1404 *ft
= (struct smb_file_time
) {
1405 .atime
= make_omit_timespec(),
1406 .ctime
= make_omit_timespec(),
1407 .mtime
= make_omit_timespec(),
1408 .create_time
= make_omit_timespec()
1413 * Initialize num_streams and streams, then call VFS op streaminfo
1416 NTSTATUS
vfs_fstreaminfo(struct files_struct
*fsp
,
1417 TALLOC_CTX
*mem_ctx
,
1418 unsigned int *num_streams
,
1419 struct stream_struct
**streams
)
1426 * Callers may pass fsp == NULL when passing smb_fname->fsp of a
1427 * symlink. This is ok, handle it here, by just return no
1428 * streams on a symlink.
1430 return NT_STATUS_OK
;
1433 if (fsp_get_pathref_fd(fsp
) == -1) {
1435 * No streams on non-real files/directories.
1437 return NT_STATUS_OK
;
1440 return SMB_VFS_FSTREAMINFO(fsp
,
1446 int vfs_fake_fd(void)
1452 * Return a valid fd, but ensure any attempt to use
1453 * it returns an error (EPIPE).
1455 ret
= pipe(pipe_fds
);
1465 * This is just a helper to make
1466 * users of vfs_fake_fd() more symmetric
1468 int vfs_fake_fd_close(int fd
)
1474 generate a file_id from a stat structure
1476 struct file_id
vfs_file_id_from_sbuf(connection_struct
*conn
, const SMB_STRUCT_STAT
*sbuf
)
1478 return SMB_VFS_FILE_ID_CREATE(conn
, sbuf
);
1481 NTSTATUS
vfs_at_fspcwd(TALLOC_CTX
*mem_ctx
,
1482 struct connection_struct
*conn
,
1483 struct files_struct
**_fsp
)
1485 struct files_struct
*fsp
= NULL
;
1487 fsp
= talloc_zero(mem_ctx
, struct files_struct
);
1489 return NT_STATUS_NO_MEMORY
;
1492 fsp
->fsp_name
= synthetic_smb_fname(fsp
, ".", NULL
, NULL
, 0, 0);
1493 if (fsp
->fsp_name
== NULL
) {
1495 return NT_STATUS_NO_MEMORY
;
1498 fsp
->fh
= fd_handle_create(fsp
);
1499 if (fsp
->fh
== NULL
) {
1501 return NT_STATUS_NO_MEMORY
;
1504 fsp_set_fd(fsp
, AT_FDCWD
);
1505 fsp
->fnum
= FNUM_FIELD_INVALID
;
1509 return NT_STATUS_OK
;
1512 int smb_vfs_call_connect(struct vfs_handle_struct
*handle
,
1513 const char *service
, const char *user
)
1516 return handle
->fns
->connect_fn(handle
, service
, user
);
1519 void smb_vfs_call_disconnect(struct vfs_handle_struct
*handle
)
1521 VFS_FIND(disconnect
);
1522 handle
->fns
->disconnect_fn(handle
);
1525 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct
*handle
,
1526 const struct smb_filename
*smb_fname
,
1531 VFS_FIND(disk_free
);
1532 return handle
->fns
->disk_free_fn(handle
, smb_fname
,
1533 bsize
, dfree
, dsize
);
1536 int smb_vfs_call_get_quota(struct vfs_handle_struct
*handle
,
1537 const struct smb_filename
*smb_fname
,
1538 enum SMB_QUOTA_TYPE qtype
,
1542 VFS_FIND(get_quota
);
1543 return handle
->fns
->get_quota_fn(handle
, smb_fname
, qtype
, id
, qt
);
1546 int smb_vfs_call_set_quota(struct vfs_handle_struct
*handle
,
1547 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1550 VFS_FIND(set_quota
);
1551 return handle
->fns
->set_quota_fn(handle
, qtype
, id
, qt
);
1554 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
1555 struct files_struct
*fsp
,
1556 struct shadow_copy_data
*shadow_copy_data
,
1559 VFS_FIND(get_shadow_copy_data
);
1560 return handle
->fns
->get_shadow_copy_data_fn(handle
, fsp
,
1564 int smb_vfs_call_statvfs(struct vfs_handle_struct
*handle
,
1565 const struct smb_filename
*smb_fname
,
1566 struct vfs_statvfs_struct
*statbuf
)
1569 return handle
->fns
->statvfs_fn(handle
, smb_fname
, statbuf
);
1572 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct
*handle
,
1573 enum timestamp_set_resolution
*p_ts_res
)
1575 VFS_FIND(fs_capabilities
);
1576 return handle
->fns
->fs_capabilities_fn(handle
, p_ts_res
);
1579 NTSTATUS
smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct
*handle
,
1580 struct dfs_GetDFSReferral
*r
)
1582 VFS_FIND(get_dfs_referrals
);
1583 return handle
->fns
->get_dfs_referrals_fn(handle
, r
);
1586 NTSTATUS
smb_vfs_call_create_dfs_pathat(struct vfs_handle_struct
*handle
,
1587 struct files_struct
*dirfsp
,
1588 const struct smb_filename
*smb_fname
,
1589 const struct referral
*reflist
,
1590 size_t referral_count
)
1592 VFS_FIND(create_dfs_pathat
);
1593 return handle
->fns
->create_dfs_pathat_fn(handle
,
1600 NTSTATUS
smb_vfs_call_read_dfs_pathat(struct vfs_handle_struct
*handle
,
1601 TALLOC_CTX
*mem_ctx
,
1602 struct files_struct
*dirfsp
,
1603 struct smb_filename
*smb_fname
,
1604 struct referral
**ppreflist
,
1605 size_t *preferral_count
)
1607 VFS_FIND(read_dfs_pathat
);
1608 return handle
->fns
->read_dfs_pathat_fn(handle
,
1616 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct
*handle
,
1617 struct files_struct
*fsp
,
1619 uint32_t attributes
)
1621 VFS_FIND(fdopendir
);
1622 return handle
->fns
->fdopendir_fn(handle
, fsp
, mask
, attributes
);
1625 struct dirent
*smb_vfs_call_readdir(struct vfs_handle_struct
*handle
,
1626 struct files_struct
*dirfsp
,
1628 SMB_STRUCT_STAT
*sbuf
)
1631 return handle
->fns
->readdir_fn(handle
, dirfsp
, dirp
, sbuf
);
1634 void smb_vfs_call_seekdir(struct vfs_handle_struct
*handle
,
1635 DIR *dirp
, long offset
)
1638 handle
->fns
->seekdir_fn(handle
, dirp
, offset
);
1641 long smb_vfs_call_telldir(struct vfs_handle_struct
*handle
,
1645 return handle
->fns
->telldir_fn(handle
, dirp
);
1648 void smb_vfs_call_rewind_dir(struct vfs_handle_struct
*handle
,
1651 VFS_FIND(rewind_dir
);
1652 handle
->fns
->rewind_dir_fn(handle
, dirp
);
1655 int smb_vfs_call_mkdirat(struct vfs_handle_struct
*handle
,
1656 struct files_struct
*dirfsp
,
1657 const struct smb_filename
*smb_fname
,
1661 return handle
->fns
->mkdirat_fn(handle
,
1667 int smb_vfs_call_closedir(struct vfs_handle_struct
*handle
,
1671 return handle
->fns
->closedir_fn(handle
, dir
);
1674 int smb_vfs_call_openat(struct vfs_handle_struct
*handle
,
1675 const struct files_struct
*dirfsp
,
1676 const struct smb_filename
*smb_fname
,
1677 struct files_struct
*fsp
,
1678 const struct vfs_open_how
*how
)
1681 return handle
->fns
->openat_fn(handle
,
1688 NTSTATUS
smb_vfs_call_create_file(struct vfs_handle_struct
*handle
,
1689 struct smb_request
*req
,
1690 struct files_struct
*dirfsp
,
1691 struct smb_filename
*smb_fname
,
1692 uint32_t access_mask
,
1693 uint32_t share_access
,
1694 uint32_t create_disposition
,
1695 uint32_t create_options
,
1696 uint32_t file_attributes
,
1697 uint32_t oplock_request
,
1698 const struct smb2_lease
*lease
,
1699 uint64_t allocation_size
,
1700 uint32_t private_flags
,
1701 struct security_descriptor
*sd
,
1702 struct ea_list
*ea_list
,
1703 files_struct
**result
,
1705 const struct smb2_create_blobs
*in_context_blobs
,
1706 struct smb2_create_blobs
*out_context_blobs
)
1708 VFS_FIND(create_file
);
1709 return handle
->fns
->create_file_fn(
1710 handle
, req
, dirfsp
, smb_fname
,
1711 access_mask
, share_access
, create_disposition
, create_options
,
1712 file_attributes
, oplock_request
, lease
, allocation_size
,
1713 private_flags
, sd
, ea_list
,
1714 result
, pinfo
, in_context_blobs
, out_context_blobs
);
1717 int smb_vfs_call_close(struct vfs_handle_struct
*handle
,
1718 struct files_struct
*fsp
)
1721 return handle
->fns
->close_fn(handle
, fsp
);
1724 ssize_t
smb_vfs_call_pread(struct vfs_handle_struct
*handle
,
1725 struct files_struct
*fsp
, void *data
, size_t n
,
1729 return handle
->fns
->pread_fn(handle
, fsp
, data
, n
, offset
);
1732 struct smb_vfs_call_pread_state
{
1733 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1735 struct vfs_aio_state vfs_aio_state
;
1738 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
);
1740 struct tevent_req
*smb_vfs_call_pread_send(struct vfs_handle_struct
*handle
,
1741 TALLOC_CTX
*mem_ctx
,
1742 struct tevent_context
*ev
,
1743 struct files_struct
*fsp
,
1745 size_t n
, off_t offset
)
1747 struct tevent_req
*req
, *subreq
;
1748 struct smb_vfs_call_pread_state
*state
;
1750 req
= tevent_req_create(mem_ctx
, &state
,
1751 struct smb_vfs_call_pread_state
);
1755 VFS_FIND(pread_send
);
1756 state
->recv_fn
= handle
->fns
->pread_recv_fn
;
1758 subreq
= handle
->fns
->pread_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1760 if (tevent_req_nomem(subreq
, req
)) {
1761 return tevent_req_post(req
, ev
);
1763 tevent_req_set_callback(subreq
, smb_vfs_call_pread_done
, req
);
1767 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
)
1769 struct tevent_req
*req
= tevent_req_callback_data(
1770 subreq
, struct tevent_req
);
1771 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1772 req
, struct smb_vfs_call_pread_state
);
1774 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1775 TALLOC_FREE(subreq
);
1776 if (state
->retval
== -1) {
1777 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1780 tevent_req_done(req
);
1783 ssize_t
SMB_VFS_PREAD_RECV(struct tevent_req
*req
,
1784 struct vfs_aio_state
*vfs_aio_state
)
1786 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1787 req
, struct smb_vfs_call_pread_state
);
1790 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1791 tevent_req_received(req
);
1794 *vfs_aio_state
= state
->vfs_aio_state
;
1795 retval
= state
->retval
;
1796 tevent_req_received(req
);
1800 ssize_t
smb_vfs_call_pwrite(struct vfs_handle_struct
*handle
,
1801 struct files_struct
*fsp
, const void *data
,
1802 size_t n
, off_t offset
)
1805 return handle
->fns
->pwrite_fn(handle
, fsp
, data
, n
, offset
);
1808 struct smb_vfs_call_pwrite_state
{
1809 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1811 struct vfs_aio_state vfs_aio_state
;
1814 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
);
1816 struct tevent_req
*smb_vfs_call_pwrite_send(struct vfs_handle_struct
*handle
,
1817 TALLOC_CTX
*mem_ctx
,
1818 struct tevent_context
*ev
,
1819 struct files_struct
*fsp
,
1821 size_t n
, off_t offset
)
1823 struct tevent_req
*req
, *subreq
;
1824 struct smb_vfs_call_pwrite_state
*state
;
1826 req
= tevent_req_create(mem_ctx
, &state
,
1827 struct smb_vfs_call_pwrite_state
);
1831 VFS_FIND(pwrite_send
);
1832 state
->recv_fn
= handle
->fns
->pwrite_recv_fn
;
1834 subreq
= handle
->fns
->pwrite_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1836 if (tevent_req_nomem(subreq
, req
)) {
1837 return tevent_req_post(req
, ev
);
1839 tevent_req_set_callback(subreq
, smb_vfs_call_pwrite_done
, req
);
1843 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
)
1845 struct tevent_req
*req
= tevent_req_callback_data(
1846 subreq
, struct tevent_req
);
1847 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1848 req
, struct smb_vfs_call_pwrite_state
);
1850 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1851 TALLOC_FREE(subreq
);
1852 if (state
->retval
== -1) {
1853 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1856 tevent_req_done(req
);
1859 ssize_t
SMB_VFS_PWRITE_RECV(struct tevent_req
*req
,
1860 struct vfs_aio_state
*vfs_aio_state
)
1862 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1863 req
, struct smb_vfs_call_pwrite_state
);
1866 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1867 tevent_req_received(req
);
1870 *vfs_aio_state
= state
->vfs_aio_state
;
1871 retval
= state
->retval
;
1872 tevent_req_received(req
);
1876 off_t
smb_vfs_call_lseek(struct vfs_handle_struct
*handle
,
1877 struct files_struct
*fsp
, off_t offset
,
1881 return handle
->fns
->lseek_fn(handle
, fsp
, offset
, whence
);
1884 ssize_t
smb_vfs_call_sendfile(struct vfs_handle_struct
*handle
, int tofd
,
1885 files_struct
*fromfsp
, const DATA_BLOB
*header
,
1886 off_t offset
, size_t count
)
1889 return handle
->fns
->sendfile_fn(handle
, tofd
, fromfsp
, header
, offset
,
1893 ssize_t
smb_vfs_call_recvfile(struct vfs_handle_struct
*handle
, int fromfd
,
1894 files_struct
*tofsp
, off_t offset
,
1898 return handle
->fns
->recvfile_fn(handle
, fromfd
, tofsp
, offset
, count
);
1901 int smb_vfs_call_renameat(struct vfs_handle_struct
*handle
,
1902 files_struct
*srcfsp
,
1903 const struct smb_filename
*smb_fname_src
,
1904 files_struct
*dstfsp
,
1905 const struct smb_filename
*smb_fname_dst
)
1908 return handle
->fns
->renameat_fn(handle
,
1915 struct smb_vfs_call_fsync_state
{
1916 int (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1918 struct vfs_aio_state vfs_aio_state
;
1921 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
);
1923 struct tevent_req
*smb_vfs_call_fsync_send(struct vfs_handle_struct
*handle
,
1924 TALLOC_CTX
*mem_ctx
,
1925 struct tevent_context
*ev
,
1926 struct files_struct
*fsp
)
1928 struct tevent_req
*req
, *subreq
;
1929 struct smb_vfs_call_fsync_state
*state
;
1931 req
= tevent_req_create(mem_ctx
, &state
,
1932 struct smb_vfs_call_fsync_state
);
1936 VFS_FIND(fsync_send
);
1937 state
->recv_fn
= handle
->fns
->fsync_recv_fn
;
1939 subreq
= handle
->fns
->fsync_send_fn(handle
, state
, ev
, fsp
);
1940 if (tevent_req_nomem(subreq
, req
)) {
1941 return tevent_req_post(req
, ev
);
1943 tevent_req_set_callback(subreq
, smb_vfs_call_fsync_done
, req
);
1947 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
)
1949 struct tevent_req
*req
= tevent_req_callback_data(
1950 subreq
, struct tevent_req
);
1951 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1952 req
, struct smb_vfs_call_fsync_state
);
1954 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1955 TALLOC_FREE(subreq
);
1956 if (state
->retval
== -1) {
1957 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1960 tevent_req_done(req
);
1963 int SMB_VFS_FSYNC_RECV(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
)
1965 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1966 req
, struct smb_vfs_call_fsync_state
);
1969 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1970 tevent_req_received(req
);
1973 *vfs_aio_state
= state
->vfs_aio_state
;
1974 retval
= state
->retval
;
1975 tevent_req_received(req
);
1980 * Synchronous version of fsync, built from backend
1981 * async VFS primitives. Uses a temporary sub-event
1982 * context (NOT NESTED).
1985 int smb_vfs_fsync_sync(files_struct
*fsp
)
1987 TALLOC_CTX
*frame
= talloc_stackframe();
1988 struct tevent_req
*req
= NULL
;
1989 struct vfs_aio_state aio_state
= { 0 };
1992 struct tevent_context
*ev
= samba_tevent_context_init(frame
);
1998 req
= SMB_VFS_FSYNC_SEND(talloc_tos(), ev
, fsp
);
2003 ok
= tevent_req_poll(req
, ev
);
2008 ret
= SMB_VFS_FSYNC_RECV(req
, &aio_state
);
2013 if (aio_state
.error
!= 0) {
2014 errno
= aio_state
.error
;
2019 int smb_vfs_call_stat(struct vfs_handle_struct
*handle
,
2020 struct smb_filename
*smb_fname
)
2023 return handle
->fns
->stat_fn(handle
, smb_fname
);
2026 int smb_vfs_call_fstat(struct vfs_handle_struct
*handle
,
2027 struct files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
2030 return handle
->fns
->fstat_fn(handle
, fsp
, sbuf
);
2033 int smb_vfs_call_lstat(struct vfs_handle_struct
*handle
,
2034 struct smb_filename
*smb_filename
)
2037 return handle
->fns
->lstat_fn(handle
, smb_filename
);
2040 int smb_vfs_call_fstatat(
2041 struct vfs_handle_struct
*handle
,
2042 const struct files_struct
*dirfsp
,
2043 const struct smb_filename
*smb_fname
,
2044 SMB_STRUCT_STAT
*sbuf
,
2048 return handle
->fns
->fstatat_fn(handle
, dirfsp
, smb_fname
, sbuf
, flags
);
2051 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct
*handle
,
2052 struct files_struct
*fsp
,
2053 const SMB_STRUCT_STAT
*sbuf
)
2055 VFS_FIND(get_alloc_size
);
2056 return handle
->fns
->get_alloc_size_fn(handle
, fsp
, sbuf
);
2059 int smb_vfs_call_unlinkat(struct vfs_handle_struct
*handle
,
2060 struct files_struct
*dirfsp
,
2061 const struct smb_filename
*smb_fname
,
2065 return handle
->fns
->unlinkat_fn(handle
,
2071 int smb_vfs_call_fchmod(struct vfs_handle_struct
*handle
,
2072 struct files_struct
*fsp
, mode_t mode
)
2075 return handle
->fns
->fchmod_fn(handle
, fsp
, mode
);
2078 int smb_vfs_call_fchown(struct vfs_handle_struct
*handle
,
2079 struct files_struct
*fsp
, uid_t uid
, gid_t gid
)
2082 return handle
->fns
->fchown_fn(handle
, fsp
, uid
, gid
);
2085 int smb_vfs_call_lchown(struct vfs_handle_struct
*handle
,
2086 const struct smb_filename
*smb_fname
,
2091 return handle
->fns
->lchown_fn(handle
, smb_fname
, uid
, gid
);
2094 int smb_vfs_call_chdir(struct vfs_handle_struct
*handle
,
2095 const struct smb_filename
*smb_fname
)
2098 return handle
->fns
->chdir_fn(handle
, smb_fname
);
2101 struct smb_filename
*smb_vfs_call_getwd(struct vfs_handle_struct
*handle
,
2105 return handle
->fns
->getwd_fn(handle
, ctx
);
2108 int smb_vfs_call_fntimes(struct vfs_handle_struct
*handle
,
2109 struct files_struct
*fsp
,
2110 struct smb_file_time
*ft
)
2113 return handle
->fns
->fntimes_fn(handle
, fsp
, 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_filesystem_sharemode(struct vfs_handle_struct
*handle
,
2134 struct files_struct
*fsp
,
2135 uint32_t share_mode
,
2136 uint32_t access_mask
)
2138 VFS_FIND(filesystem_sharemode
);
2139 return handle
->fns
->filesystem_sharemode_fn(handle
,
2145 int smb_vfs_call_fcntl(struct vfs_handle_struct
*handle
,
2146 struct files_struct
*fsp
, int cmd
, ...)
2153 va_start(cmd_arg
, cmd
);
2154 result
= handle
->fns
->fcntl_fn(handle
, fsp
, cmd
, cmd_arg
);
2160 int smb_vfs_call_linux_setlease(struct vfs_handle_struct
*handle
,
2161 struct files_struct
*fsp
, int leasetype
)
2163 VFS_FIND(linux_setlease
);
2164 return handle
->fns
->linux_setlease_fn(handle
, fsp
, leasetype
);
2167 int smb_vfs_call_symlinkat(struct vfs_handle_struct
*handle
,
2168 const struct smb_filename
*link_target
,
2169 struct files_struct
*dirfsp
,
2170 const struct smb_filename
*new_smb_fname
)
2172 VFS_FIND(symlinkat
);
2173 return handle
->fns
->symlinkat_fn(handle
,
2179 int smb_vfs_call_readlinkat(struct vfs_handle_struct
*handle
,
2180 const struct files_struct
*dirfsp
,
2181 const struct smb_filename
*smb_fname
,
2185 VFS_FIND(readlinkat
);
2186 return handle
->fns
->readlinkat_fn(handle
,
2193 int smb_vfs_call_linkat(struct vfs_handle_struct
*handle
,
2194 struct files_struct
*srcfsp
,
2195 const struct smb_filename
*old_smb_fname
,
2196 struct files_struct
*dstfsp
,
2197 const struct smb_filename
*new_smb_fname
,
2201 return handle
->fns
->linkat_fn(handle
,
2209 int smb_vfs_call_mknodat(struct vfs_handle_struct
*handle
,
2210 struct files_struct
*dirfsp
,
2211 const struct smb_filename
*smb_fname
,
2216 return handle
->fns
->mknodat_fn(handle
,
2223 struct smb_filename
*smb_vfs_call_realpath(struct vfs_handle_struct
*handle
,
2225 const struct smb_filename
*smb_fname
)
2228 return handle
->fns
->realpath_fn(handle
, ctx
, smb_fname
);
2231 int smb_vfs_call_fchflags(struct vfs_handle_struct
*handle
,
2232 struct files_struct
*fsp
,
2236 return handle
->fns
->fchflags_fn(handle
, fsp
, flags
);
2239 struct file_id
smb_vfs_call_file_id_create(struct vfs_handle_struct
*handle
,
2240 const SMB_STRUCT_STAT
*sbuf
)
2242 VFS_FIND(file_id_create
);
2243 return handle
->fns
->file_id_create_fn(handle
, sbuf
);
2246 uint64_t smb_vfs_call_fs_file_id(struct vfs_handle_struct
*handle
,
2247 const SMB_STRUCT_STAT
*sbuf
)
2249 VFS_FIND(fs_file_id
);
2250 return handle
->fns
->fs_file_id_fn(handle
, sbuf
);
2253 NTSTATUS
smb_vfs_call_fstreaminfo(struct vfs_handle_struct
*handle
,
2254 struct files_struct
*fsp
,
2255 TALLOC_CTX
*mem_ctx
,
2256 unsigned int *num_streams
,
2257 struct stream_struct
**streams
)
2259 VFS_FIND(fstreaminfo
);
2260 return handle
->fns
->fstreaminfo_fn(handle
, fsp
, mem_ctx
,
2261 num_streams
, streams
);
2264 NTSTATUS
smb_vfs_call_get_real_filename_at(struct vfs_handle_struct
*handle
,
2265 struct files_struct
*dirfsp
,
2267 TALLOC_CTX
*mem_ctx
,
2270 VFS_FIND(get_real_filename_at
);
2271 return handle
->fns
->get_real_filename_at_fn(
2272 handle
, dirfsp
, name
, mem_ctx
, found_name
);
2275 const char *smb_vfs_call_connectpath(struct vfs_handle_struct
*handle
,
2276 const struct smb_filename
*smb_fname
)
2278 VFS_FIND(connectpath
);
2279 return handle
->fns
->connectpath_fn(handle
, smb_fname
);
2282 bool smb_vfs_call_strict_lock_check(struct vfs_handle_struct
*handle
,
2283 struct files_struct
*fsp
,
2284 struct lock_struct
*plock
)
2286 VFS_FIND(strict_lock_check
);
2287 return handle
->fns
->strict_lock_check_fn(handle
, fsp
, plock
);
2290 NTSTATUS
smb_vfs_call_translate_name(struct vfs_handle_struct
*handle
,
2292 enum vfs_translate_direction direction
,
2293 TALLOC_CTX
*mem_ctx
,
2296 VFS_FIND(translate_name
);
2297 return handle
->fns
->translate_name_fn(handle
, name
, direction
, mem_ctx
,
2301 NTSTATUS
smb_vfs_call_parent_pathname(struct vfs_handle_struct
*handle
,
2302 TALLOC_CTX
*mem_ctx
,
2303 const struct smb_filename
*smb_fname_in
,
2304 struct smb_filename
**parent_dir_out
,
2305 struct smb_filename
**atname_out
)
2307 VFS_FIND(parent_pathname
);
2308 return handle
->fns
->parent_pathname_fn(handle
,
2315 NTSTATUS
smb_vfs_call_fsctl(struct vfs_handle_struct
*handle
,
2316 struct files_struct
*fsp
,
2320 const uint8_t *in_data
,
2323 uint32_t max_out_len
,
2327 return handle
->fns
->fsctl_fn(handle
, fsp
, ctx
, function
, req_flags
,
2328 in_data
, in_len
, out_data
, max_out_len
,
2332 NTSTATUS
smb_vfs_call_fget_dos_attributes(struct vfs_handle_struct
*handle
,
2333 struct files_struct
*fsp
,
2336 VFS_FIND(fget_dos_attributes
);
2337 return handle
->fns
->fget_dos_attributes_fn(handle
, fsp
, dosmode
);
2340 NTSTATUS
smb_vfs_call_fset_dos_attributes(struct vfs_handle_struct
*handle
,
2341 struct files_struct
*fsp
,
2344 VFS_FIND(fset_dos_attributes
);
2345 return handle
->fns
->fset_dos_attributes_fn(handle
, fsp
, dosmode
);
2348 struct tevent_req
*smb_vfs_call_offload_read_send(TALLOC_CTX
*mem_ctx
,
2349 struct tevent_context
*ev
,
2350 struct vfs_handle_struct
*handle
,
2351 struct files_struct
*fsp
,
2357 VFS_FIND(offload_read_send
);
2358 return handle
->fns
->offload_read_send_fn(mem_ctx
, ev
, handle
,
2360 ttl
, offset
, to_copy
);
2363 NTSTATUS
smb_vfs_call_offload_read_recv(struct tevent_req
*req
,
2364 struct vfs_handle_struct
*handle
,
2365 TALLOC_CTX
*mem_ctx
,
2368 DATA_BLOB
*token_blob
)
2370 VFS_FIND(offload_read_recv
);
2371 return handle
->fns
->offload_read_recv_fn(req
, handle
, mem_ctx
, flags
, xferlen
, token_blob
);
2374 struct tevent_req
*smb_vfs_call_offload_write_send(struct vfs_handle_struct
*handle
,
2375 TALLOC_CTX
*mem_ctx
,
2376 struct tevent_context
*ev
,
2379 off_t transfer_offset
,
2380 struct files_struct
*dest_fsp
,
2384 VFS_FIND(offload_write_send
);
2385 return handle
->fns
->offload_write_send_fn(handle
, mem_ctx
, ev
, fsctl
,
2386 token
, transfer_offset
,
2387 dest_fsp
, dest_off
, num
);
2390 NTSTATUS
smb_vfs_call_offload_write_recv(struct vfs_handle_struct
*handle
,
2391 struct tevent_req
*req
,
2394 VFS_FIND(offload_write_recv
);
2395 return handle
->fns
->offload_write_recv_fn(handle
, req
, copied
);
2398 struct smb_vfs_call_get_dos_attributes_state
{
2399 files_struct
*dir_fsp
;
2400 NTSTATUS (*recv_fn
)(struct tevent_req
*req
,
2401 struct vfs_aio_state
*aio_state
,
2403 struct vfs_aio_state aio_state
;
2404 uint32_t dos_attributes
;
2407 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req
*subreq
);
2409 struct tevent_req
*smb_vfs_call_get_dos_attributes_send(
2410 TALLOC_CTX
*mem_ctx
,
2411 struct tevent_context
*ev
,
2412 struct vfs_handle_struct
*handle
,
2413 files_struct
*dir_fsp
,
2414 struct smb_filename
*smb_fname
)
2416 struct tevent_req
*req
= NULL
;
2417 struct smb_vfs_call_get_dos_attributes_state
*state
= NULL
;
2418 struct tevent_req
*subreq
= NULL
;
2420 req
= tevent_req_create(mem_ctx
, &state
,
2421 struct smb_vfs_call_get_dos_attributes_state
);
2426 VFS_FIND(get_dos_attributes_send
);
2428 *state
= (struct smb_vfs_call_get_dos_attributes_state
) {
2430 .recv_fn
= handle
->fns
->get_dos_attributes_recv_fn
,
2433 subreq
= handle
->fns
->get_dos_attributes_send_fn(mem_ctx
,
2438 if (tevent_req_nomem(subreq
, req
)) {
2439 return tevent_req_post(req
, ev
);
2441 tevent_req_defer_callback(req
, ev
);
2443 tevent_req_set_callback(subreq
,
2444 smb_vfs_call_get_dos_attributes_done
,
2450 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req
*subreq
)
2452 struct tevent_req
*req
=
2453 tevent_req_callback_data(subreq
,
2455 struct smb_vfs_call_get_dos_attributes_state
*state
=
2456 tevent_req_data(req
,
2457 struct smb_vfs_call_get_dos_attributes_state
);
2462 * Make sure we run as the user again
2464 ok
= change_to_user_and_service_by_fsp(state
->dir_fsp
);
2467 status
= state
->recv_fn(subreq
,
2469 &state
->dos_attributes
);
2470 TALLOC_FREE(subreq
);
2471 if (tevent_req_nterror(req
, status
)) {
2475 tevent_req_done(req
);
2478 NTSTATUS
smb_vfs_call_get_dos_attributes_recv(
2479 struct tevent_req
*req
,
2480 struct vfs_aio_state
*aio_state
,
2481 uint32_t *dos_attributes
)
2483 struct smb_vfs_call_get_dos_attributes_state
*state
=
2484 tevent_req_data(req
,
2485 struct smb_vfs_call_get_dos_attributes_state
);
2488 if (tevent_req_is_nterror(req
, &status
)) {
2489 tevent_req_received(req
);
2493 *aio_state
= state
->aio_state
;
2494 *dos_attributes
= state
->dos_attributes
;
2495 tevent_req_received(req
);
2496 return NT_STATUS_OK
;
2499 NTSTATUS
smb_vfs_call_fget_compression(vfs_handle_struct
*handle
,
2500 TALLOC_CTX
*mem_ctx
,
2501 struct files_struct
*fsp
,
2502 uint16_t *_compression_fmt
)
2504 VFS_FIND(fget_compression
);
2505 return handle
->fns
->fget_compression_fn(handle
, mem_ctx
, fsp
,
2509 NTSTATUS
smb_vfs_call_set_compression(vfs_handle_struct
*handle
,
2510 TALLOC_CTX
*mem_ctx
,
2511 struct files_struct
*fsp
,
2512 uint16_t compression_fmt
)
2514 VFS_FIND(set_compression
);
2515 return handle
->fns
->set_compression_fn(handle
, mem_ctx
, fsp
,
2519 NTSTATUS
smb_vfs_call_snap_check_path(vfs_handle_struct
*handle
,
2520 TALLOC_CTX
*mem_ctx
,
2521 const char *service_path
,
2524 VFS_FIND(snap_check_path
);
2525 return handle
->fns
->snap_check_path_fn(handle
, mem_ctx
, service_path
,
2529 NTSTATUS
smb_vfs_call_snap_create(struct vfs_handle_struct
*handle
,
2530 TALLOC_CTX
*mem_ctx
,
2531 const char *base_volume
,
2537 VFS_FIND(snap_create
);
2538 return handle
->fns
->snap_create_fn(handle
, mem_ctx
, base_volume
, tstamp
,
2539 rw
, base_path
, snap_path
);
2542 NTSTATUS
smb_vfs_call_snap_delete(struct vfs_handle_struct
*handle
,
2543 TALLOC_CTX
*mem_ctx
,
2547 VFS_FIND(snap_delete
);
2548 return handle
->fns
->snap_delete_fn(handle
, mem_ctx
, base_path
,
2552 NTSTATUS
smb_vfs_call_fget_nt_acl(struct vfs_handle_struct
*handle
,
2553 struct files_struct
*fsp
,
2554 uint32_t security_info
,
2555 TALLOC_CTX
*mem_ctx
,
2556 struct security_descriptor
**ppdesc
)
2558 VFS_FIND(fget_nt_acl
);
2559 return handle
->fns
->fget_nt_acl_fn(handle
, fsp
, security_info
,
2563 NTSTATUS
smb_vfs_call_fset_nt_acl(struct vfs_handle_struct
*handle
,
2564 struct files_struct
*fsp
,
2565 uint32_t security_info_sent
,
2566 const struct security_descriptor
*psd
)
2568 VFS_FIND(fset_nt_acl
);
2569 return handle
->fns
->fset_nt_acl_fn(handle
, fsp
, security_info_sent
,
2573 NTSTATUS
smb_vfs_call_audit_file(struct vfs_handle_struct
*handle
,
2574 struct smb_filename
*file
,
2575 struct security_acl
*sacl
,
2576 uint32_t access_requested
,
2577 uint32_t access_denied
)
2579 VFS_FIND(audit_file
);
2580 return handle
->fns
->audit_file_fn(handle
,
2587 SMB_ACL_T
smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct
*handle
,
2588 struct files_struct
*fsp
,
2589 SMB_ACL_TYPE_T type
,
2590 TALLOC_CTX
*mem_ctx
)
2592 VFS_FIND(sys_acl_get_fd
);
2593 return handle
->fns
->sys_acl_get_fd_fn(handle
, fsp
, type
, mem_ctx
);
2596 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct
*handle
,
2597 struct files_struct
*fsp
,
2598 TALLOC_CTX
*mem_ctx
,
2599 char **blob_description
,
2602 VFS_FIND(sys_acl_blob_get_fd
);
2603 return handle
->fns
->sys_acl_blob_get_fd_fn(handle
, fsp
, mem_ctx
, blob_description
, blob
);
2606 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct
*handle
,
2607 struct files_struct
*fsp
,
2608 SMB_ACL_TYPE_T type
,
2611 VFS_FIND(sys_acl_set_fd
);
2612 return handle
->fns
->sys_acl_set_fd_fn(handle
, fsp
, type
, theacl
);
2615 int smb_vfs_call_sys_acl_delete_def_fd(struct vfs_handle_struct
*handle
,
2616 struct files_struct
*fsp
)
2618 VFS_FIND(sys_acl_delete_def_fd
);
2619 return handle
->fns
->sys_acl_delete_def_fd_fn(handle
, fsp
);
2622 struct smb_vfs_call_getxattrat_state
{
2623 files_struct
*dir_fsp
;
2624 ssize_t (*recv_fn
)(struct tevent_req
*req
,
2625 struct vfs_aio_state
*aio_state
,
2626 TALLOC_CTX
*mem_ctx
,
2627 uint8_t **xattr_value
);
2629 uint8_t *xattr_value
;
2630 struct vfs_aio_state aio_state
;
2633 static void smb_vfs_call_getxattrat_done(struct tevent_req
*subreq
);
2635 struct tevent_req
*smb_vfs_call_getxattrat_send(
2636 TALLOC_CTX
*mem_ctx
,
2637 struct tevent_context
*ev
,
2638 struct vfs_handle_struct
*handle
,
2639 files_struct
*dir_fsp
,
2640 const struct smb_filename
*smb_fname
,
2641 const char *xattr_name
,
2644 struct tevent_req
*req
= NULL
;
2645 struct smb_vfs_call_getxattrat_state
*state
= NULL
;
2646 struct tevent_req
*subreq
= NULL
;
2648 req
= tevent_req_create(mem_ctx
, &state
,
2649 struct smb_vfs_call_getxattrat_state
);
2654 VFS_FIND(getxattrat_send
);
2656 *state
= (struct smb_vfs_call_getxattrat_state
) {
2658 .recv_fn
= handle
->fns
->getxattrat_recv_fn
,
2661 subreq
= handle
->fns
->getxattrat_send_fn(mem_ctx
,
2668 if (tevent_req_nomem(subreq
, req
)) {
2669 return tevent_req_post(req
, ev
);
2671 tevent_req_defer_callback(req
, ev
);
2673 tevent_req_set_callback(subreq
, smb_vfs_call_getxattrat_done
, req
);
2677 static void smb_vfs_call_getxattrat_done(struct tevent_req
*subreq
)
2679 struct tevent_req
*req
= tevent_req_callback_data(
2680 subreq
, struct tevent_req
);
2681 struct smb_vfs_call_getxattrat_state
*state
= tevent_req_data(
2682 req
, struct smb_vfs_call_getxattrat_state
);
2686 * Make sure we run as the user again
2688 ok
= change_to_user_and_service_by_fsp(state
->dir_fsp
);
2691 state
->retval
= state
->recv_fn(subreq
,
2694 &state
->xattr_value
);
2695 TALLOC_FREE(subreq
);
2696 if (state
->retval
== -1) {
2697 tevent_req_error(req
, state
->aio_state
.error
);
2701 tevent_req_done(req
);
2704 ssize_t
smb_vfs_call_getxattrat_recv(struct tevent_req
*req
,
2705 struct vfs_aio_state
*aio_state
,
2706 TALLOC_CTX
*mem_ctx
,
2707 uint8_t **xattr_value
)
2709 struct smb_vfs_call_getxattrat_state
*state
= tevent_req_data(
2710 req
, struct smb_vfs_call_getxattrat_state
);
2713 if (tevent_req_is_unix_error(req
, &aio_state
->error
)) {
2714 tevent_req_received(req
);
2718 *aio_state
= state
->aio_state
;
2719 xattr_size
= state
->retval
;
2720 if (xattr_value
!= NULL
) {
2721 *xattr_value
= talloc_move(mem_ctx
, &state
->xattr_value
);
2724 tevent_req_received(req
);
2728 ssize_t
smb_vfs_call_fgetxattr(struct vfs_handle_struct
*handle
,
2729 struct files_struct
*fsp
, const char *name
,
2730 void *value
, size_t size
)
2732 VFS_FIND(fgetxattr
);
2733 return handle
->fns
->fgetxattr_fn(handle
, fsp
, name
, value
, size
);
2736 ssize_t
smb_vfs_call_flistxattr(struct vfs_handle_struct
*handle
,
2737 struct files_struct
*fsp
, char *list
,
2740 VFS_FIND(flistxattr
);
2741 return handle
->fns
->flistxattr_fn(handle
, fsp
, list
, size
);
2744 int smb_vfs_call_fremovexattr(struct vfs_handle_struct
*handle
,
2745 struct files_struct
*fsp
, const char *name
)
2747 VFS_FIND(fremovexattr
);
2748 return handle
->fns
->fremovexattr_fn(handle
, fsp
, name
);
2751 int smb_vfs_call_fsetxattr(struct vfs_handle_struct
*handle
,
2752 struct files_struct
*fsp
, const char *name
,
2753 const void *value
, size_t size
, int flags
)
2755 VFS_FIND(fsetxattr
);
2756 return handle
->fns
->fsetxattr_fn(handle
, fsp
, name
, value
, size
, flags
);
2759 bool smb_vfs_call_aio_force(struct vfs_handle_struct
*handle
,
2760 struct files_struct
*fsp
)
2762 VFS_FIND(aio_force
);
2763 return handle
->fns
->aio_force_fn(handle
, fsp
);
2766 NTSTATUS
smb_vfs_call_durable_cookie(struct vfs_handle_struct
*handle
,
2767 struct files_struct
*fsp
,
2768 TALLOC_CTX
*mem_ctx
,
2771 VFS_FIND(durable_cookie
);
2772 return handle
->fns
->durable_cookie_fn(handle
, fsp
, mem_ctx
, cookie
);
2775 NTSTATUS
smb_vfs_call_durable_disconnect(struct vfs_handle_struct
*handle
,
2776 struct files_struct
*fsp
,
2777 const DATA_BLOB old_cookie
,
2778 TALLOC_CTX
*mem_ctx
,
2779 DATA_BLOB
*new_cookie
)
2781 VFS_FIND(durable_disconnect
);
2782 return handle
->fns
->durable_disconnect_fn(handle
, fsp
, old_cookie
,
2783 mem_ctx
, new_cookie
);
2786 NTSTATUS
smb_vfs_call_durable_reconnect(struct vfs_handle_struct
*handle
,
2787 struct smb_request
*smb1req
,
2788 struct smbXsrv_open
*op
,
2789 const DATA_BLOB old_cookie
,
2790 TALLOC_CTX
*mem_ctx
,
2791 struct files_struct
**fsp
,
2792 DATA_BLOB
*new_cookie
)
2794 VFS_FIND(durable_reconnect
);
2795 return handle
->fns
->durable_reconnect_fn(handle
, smb1req
, op
,
2796 old_cookie
, mem_ctx
, fsp
,
2800 NTSTATUS
smb_vfs_call_freaddir_attr(struct vfs_handle_struct
*handle
,
2801 struct files_struct
*fsp
,
2802 TALLOC_CTX
*mem_ctx
,
2803 struct readdir_attr_data
**attr_data
)
2805 VFS_FIND(freaddir_attr
);
2806 return handle
->fns
->freaddir_attr_fn(handle
,