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"
37 #define DBGC_CLASS DBGC_VFS
42 struct vfs_fsp_data
*next
;
43 struct vfs_handle_struct
*owner
;
44 void (*destroy
)(void *p_data
);
46 /* NOTE: This structure contains four pointers so that we can guarantee
47 * that the end of the structure is always both 4-byte and 8-byte aligned.
51 struct vfs_init_function_entry
{
53 struct vfs_init_function_entry
*prev
, *next
;
54 const struct vfs_fn_pointers
*fns
;
57 /****************************************************************************
58 maintain the list of available backends
59 ****************************************************************************/
61 static struct vfs_init_function_entry
*vfs_find_backend_entry(const char *name
)
63 struct vfs_init_function_entry
*entry
= backends
;
65 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name
));
68 if (strcmp(entry
->name
, name
)==0) return entry
;
75 NTSTATUS
smb_register_vfs(int version
, const char *name
,
76 const struct vfs_fn_pointers
*fns
)
78 struct vfs_init_function_entry
*entry
= backends
;
80 if ((version
!= SMB_VFS_INTERFACE_VERSION
)) {
81 DEBUG(0, ("Failed to register vfs module.\n"
82 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
83 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
84 "Please recompile against the current Samba Version!\n",
85 version
, SMB_VFS_INTERFACE_VERSION
));
86 return NT_STATUS_OBJECT_TYPE_MISMATCH
;
89 if (!name
|| !name
[0]) {
90 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
91 return NT_STATUS_INVALID_PARAMETER
;
94 if (vfs_find_backend_entry(name
)) {
95 DEBUG(0,("VFS module %s already loaded!\n", name
));
96 return NT_STATUS_OBJECT_NAME_COLLISION
;
99 entry
= SMB_XMALLOC_P(struct vfs_init_function_entry
);
100 entry
->name
= smb_xstrdup(name
);
103 DLIST_ADD(backends
, entry
);
104 DEBUG(5, ("Successfully added vfs backend '%s'\n", name
));
108 /****************************************************************************
109 initialise default vfs hooks
110 ****************************************************************************/
112 static void vfs_init_default(connection_struct
*conn
)
114 DEBUG(3, ("Initialising default vfs hooks\n"));
115 vfs_init_custom(conn
, DEFAULT_VFS_MODULE_NAME
);
118 /****************************************************************************
119 initialise custom vfs hooks
120 ****************************************************************************/
122 bool vfs_init_custom(connection_struct
*conn
, const char *vfs_object
)
124 char *module_path
= NULL
;
125 char *module_name
= NULL
;
126 char *module_param
= NULL
, *p
;
127 vfs_handle_struct
*handle
;
128 const struct vfs_init_function_entry
*entry
;
130 if (!conn
||!vfs_object
||!vfs_object
[0]) {
131 DEBUG(0, ("vfs_init_custom() called with NULL pointer or "
132 "empty vfs_object!\n"));
137 static_init_vfs(NULL
);
140 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object
));
142 module_path
= smb_xstrdup(vfs_object
);
144 p
= strchr_m(module_path
, ':');
149 trim_char(module_param
, ' ', ' ');
152 trim_char(module_path
, ' ', ' ');
154 module_name
= smb_xstrdup(module_path
);
156 if ((module_name
[0] == '/') &&
157 (strcmp(module_path
, DEFAULT_VFS_MODULE_NAME
) != 0)) {
160 * Extract the module name from the path. Just use the base
161 * name of the last path component.
164 SAFE_FREE(module_name
);
165 module_name
= smb_xstrdup(strrchr_m(module_path
, '/')+1);
167 p
= strchr_m(module_name
, '.');
174 /* First, try to load the module with the new module system */
175 entry
= vfs_find_backend_entry(module_name
);
179 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
182 status
= smb_load_module("vfs", module_path
);
183 if (!NT_STATUS_IS_OK(status
)) {
184 DEBUG(0, ("error probing vfs module '%s': %s\n",
185 module_path
, nt_errstr(status
)));
189 entry
= vfs_find_backend_entry(module_name
);
191 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object
));
196 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object
));
198 handle
= talloc_zero(conn
, vfs_handle_struct
);
200 DEBUG(0,("TALLOC_ZERO() failed!\n"));
204 handle
->fns
= entry
->fns
;
206 handle
->param
= talloc_strdup(conn
, module_param
);
208 DLIST_ADD(conn
->vfs_handles
, handle
);
210 SAFE_FREE(module_path
);
211 SAFE_FREE(module_name
);
215 SAFE_FREE(module_path
);
216 SAFE_FREE(module_name
);
220 /*****************************************************************
221 Allow VFS modules to extend files_struct with VFS-specific state.
222 This will be ok for small numbers of extensions, but might need to
223 be refactored if it becomes more widely used.
224 ******************************************************************/
226 #define EXT_DATA_AREA(e) ((uint8_t *)(e) + sizeof(struct vfs_fsp_data))
228 void *vfs_add_fsp_extension_notype(vfs_handle_struct
*handle
,
229 files_struct
*fsp
, size_t ext_size
,
230 void (*destroy_fn
)(void *p_data
))
232 struct vfs_fsp_data
*ext
;
235 /* Prevent VFS modules adding multiple extensions. */
236 if ((ext_data
= vfs_fetch_fsp_extension(handle
, fsp
))) {
240 ext
= (struct vfs_fsp_data
*)TALLOC_ZERO(
241 handle
->conn
, sizeof(struct vfs_fsp_data
) + ext_size
);
247 ext
->next
= fsp
->vfs_extension
;
248 ext
->destroy
= destroy_fn
;
249 fsp
->vfs_extension
= ext
;
250 return EXT_DATA_AREA(ext
);
253 void vfs_remove_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
255 struct vfs_fsp_data
*curr
;
256 struct vfs_fsp_data
*prev
;
258 for (curr
= fsp
->vfs_extension
, prev
= NULL
;
260 prev
= curr
, curr
= curr
->next
) {
261 if (curr
->owner
== handle
) {
263 prev
->next
= curr
->next
;
265 fsp
->vfs_extension
= curr
->next
;
268 curr
->destroy(EXT_DATA_AREA(curr
));
276 void vfs_remove_all_fsp_extensions(files_struct
*fsp
)
278 struct vfs_fsp_data
*curr
;
279 struct vfs_fsp_data
*next
;
281 for (curr
= fsp
->vfs_extension
; curr
; curr
= next
) {
284 fsp
->vfs_extension
= next
;
287 curr
->destroy(EXT_DATA_AREA(curr
));
293 void *vfs_memctx_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
295 struct vfs_fsp_data
*head
;
297 for (head
= fsp
->vfs_extension
; head
; head
= head
->next
) {
298 if (head
->owner
== handle
) {
306 void *vfs_fetch_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
308 struct vfs_fsp_data
*head
;
310 head
= (struct vfs_fsp_data
*)vfs_memctx_fsp_extension(handle
, fsp
);
312 return EXT_DATA_AREA(head
);
321 * Ensure this module catches all VFS functions.
324 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers
* fns
,
327 bool missing_fn
= false;
329 const uintptr_t *end
= (const uintptr_t *)(fns
+ 1);
331 for (idx
= 0; ((const uintptr_t *)fns
+ idx
) < end
; idx
++) {
332 if (*((const uintptr_t *)fns
+ idx
) == 0) {
333 DBG_ERR("VFS function at index %d not implemented "
334 "in module %s\n", idx
, module
);
340 smb_panic("Required VFS function not implemented in module.\n");
344 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers
* fns
,
350 /*****************************************************************
352 ******************************************************************/
354 bool smbd_vfs_init(connection_struct
*conn
)
356 const char **vfs_objects
;
360 /* Normal share - initialise with disk access functions */
361 vfs_init_default(conn
);
363 /* No need to load vfs modules for printer connections */
368 vfs_objects
= lp_vfs_objects(SNUM(conn
));
370 /* Override VFS functions if 'vfs object' was not specified*/
371 if (!vfs_objects
|| !vfs_objects
[0])
374 for (i
=0; vfs_objects
[i
] ;) {
378 for (j
=i
-1; j
>= 0; j
--) {
379 if (!vfs_init_custom(conn
, vfs_objects
[j
])) {
380 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects
[j
]));
387 /*******************************************************************
388 Check if a file exists in the vfs.
389 ********************************************************************/
391 NTSTATUS
vfs_file_exist(connection_struct
*conn
, struct smb_filename
*smb_fname
)
393 /* Only return OK if stat was successful and S_ISREG */
394 if ((SMB_VFS_STAT(conn
, smb_fname
) != -1) &&
395 S_ISREG(smb_fname
->st
.st_ex_mode
)) {
399 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
402 ssize_t
vfs_pwrite_data(struct smb_request
*req
,
411 if (req
&& req
->unread_bytes
) {
412 int sockfd
= req
->xconn
->transport
.sock
;
413 SMB_ASSERT(req
->unread_bytes
== N
);
414 /* VFS_RECVFILE must drain the socket
415 * before returning. */
416 req
->unread_bytes
= 0;
418 * Leave the socket non-blocking and
419 * use SMB_VFS_RECVFILE. If it returns
420 * EAGAIN || EWOULDBLOCK temporarily set
421 * the socket blocking and retry
425 ret
= SMB_VFS_RECVFILE(sockfd
,
429 if (ret
== 0 || (ret
== -1 &&
431 errno
== EWOULDBLOCK
))) {
433 /* Ensure the socket is blocking. */
434 old_flags
= fcntl(sockfd
, F_GETFL
, 0);
435 if (set_blocking(sockfd
, true) == -1) {
438 ret
= SMB_VFS_RECVFILE(sockfd
,
442 if (fcntl(sockfd
, F_SETFL
, old_flags
) == -1) {
449 return (ssize_t
)total
;
451 /* Any other error case. */
457 return (ssize_t
)total
;
461 ret
= SMB_VFS_PWRITE(fsp
, buffer
+ total
, N
- total
,
471 return (ssize_t
)total
;
473 /****************************************************************************
474 An allocate file space call using the vfs interface.
475 Allocates space for a file from a filedescriptor.
476 Returns 0 on success, -1 on failure.
477 ****************************************************************************/
479 int vfs_allocate_file_space(files_struct
*fsp
, uint64_t len
)
482 connection_struct
*conn
= fsp
->conn
;
483 uint64_t space_avail
;
484 uint64_t bsize
,dfree
,dsize
;
488 * Actually try and commit the space on disk....
491 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
492 fsp_str_dbg(fsp
), (double)len
));
494 if (((off_t
)len
) < 0) {
495 DEBUG(0,("vfs_allocate_file_space: %s negative len "
496 "requested.\n", fsp_str_dbg(fsp
)));
501 status
= vfs_stat_fsp(fsp
);
502 if (!NT_STATUS_IS_OK(status
)) {
506 if (len
== (uint64_t)fsp
->fsp_name
->st
.st_ex_size
)
509 if (len
< (uint64_t)fsp
->fsp_name
->st
.st_ex_size
) {
510 /* Shrink - use ftruncate. */
512 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current "
513 "size %.0f\n", fsp_str_dbg(fsp
),
514 (double)fsp
->fsp_name
->st
.st_ex_size
));
516 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
518 flush_write_cache(fsp
, SAMBA_SIZECHANGE_FLUSH
);
519 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, (off_t
)len
)) != -1) {
520 set_filelen_write_cache(fsp
, len
);
523 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
528 /* Grow - we need to test if we have enough space. */
530 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
532 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
533 /* See if we have a syscall that will allocate beyond
534 end-of-file without changing EOF. */
535 ret
= SMB_VFS_FALLOCATE(fsp
, VFS_FALLOCATE_FL_KEEP_SIZE
,
541 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
544 /* We changed the allocation size on disk, but not
545 EOF - exactly as required. We're done ! */
549 if (ret
== -1 && errno
== ENOSPC
) {
553 len
-= fsp
->fsp_name
->st
.st_ex_size
;
554 len
/= 1024; /* Len is now number of 1k blocks needed. */
556 get_dfree_info(conn
, fsp
->fsp_name
, &bsize
, &dfree
, &dsize
);
557 if (space_avail
== (uint64_t)-1) {
561 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
562 "needed blocks = %.0f, space avail = %.0f\n",
563 fsp_str_dbg(fsp
), (double)fsp
->fsp_name
->st
.st_ex_size
, (double)len
,
564 (double)space_avail
));
566 if (len
> space_avail
) {
574 /****************************************************************************
575 A vfs set_filelen call.
576 set the length of a file from a filedescriptor.
577 Returns 0 on success, -1 on failure.
578 ****************************************************************************/
580 int vfs_set_filelen(files_struct
*fsp
, off_t len
)
584 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
586 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
587 fsp_str_dbg(fsp
), (double)len
));
588 flush_write_cache(fsp
, SAMBA_SIZECHANGE_FLUSH
);
589 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, len
)) != -1) {
590 set_filelen_write_cache(fsp
, len
);
591 notify_fname(fsp
->conn
, NOTIFY_ACTION_MODIFIED
,
592 FILE_NOTIFY_CHANGE_SIZE
593 | FILE_NOTIFY_CHANGE_ATTRIBUTES
,
594 fsp
->fsp_name
->base_name
);
597 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
602 /****************************************************************************
603 A slow version of fallocate. Fallback code if SMB_VFS_FALLOCATE
604 fails. Needs to be outside of the default version of SMB_VFS_FALLOCATE
605 as this is also called from the default SMB_VFS_FTRUNCATE code.
606 Always extends the file size.
607 Returns 0 on success, -1 on failure.
608 ****************************************************************************/
610 #define SPARSE_BUF_WRITE_SIZE (32*1024)
612 int vfs_slow_fallocate(files_struct
*fsp
, off_t offset
, off_t len
)
618 sparse_buf
= SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE
);
625 while (total
< len
) {
626 size_t curr_write_size
= MIN(SPARSE_BUF_WRITE_SIZE
, (len
- total
));
628 pwrite_ret
= SMB_VFS_PWRITE(fsp
, sparse_buf
, curr_write_size
, offset
+ total
);
629 if (pwrite_ret
== -1) {
630 int saved_errno
= errno
;
631 DEBUG(10,("vfs_slow_fallocate: SMB_VFS_PWRITE for file "
632 "%s failed with error %s\n",
633 fsp_str_dbg(fsp
), strerror(saved_errno
)));
643 /****************************************************************************
644 A vfs fill sparse call.
645 Writes zeros from the end of file to len, if len is greater than EOF.
646 Used only by strict_sync.
647 Returns 0 on success, -1 on failure.
648 ****************************************************************************/
650 int vfs_fill_sparse(files_struct
*fsp
, off_t len
)
657 status
= vfs_stat_fsp(fsp
);
658 if (!NT_STATUS_IS_OK(status
)) {
662 if (len
<= fsp
->fsp_name
->st
.st_ex_size
) {
667 if (S_ISFIFO(fsp
->fsp_name
->st
.st_ex_mode
)) {
672 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
673 "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp
),
674 (double)fsp
->fsp_name
->st
.st_ex_size
, (double)len
,
675 (double)(len
- fsp
->fsp_name
->st
.st_ex_size
)));
677 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
679 flush_write_cache(fsp
, SAMBA_SIZECHANGE_FLUSH
);
681 offset
= fsp
->fsp_name
->st
.st_ex_size
;
682 num_to_write
= len
- fsp
->fsp_name
->st
.st_ex_size
;
684 /* Only do this on non-stream file handles. */
685 if (fsp
->base_fsp
== NULL
) {
686 /* for allocation try fallocate first. This can fail on some
687 * platforms e.g. when the filesystem doesn't support it and no
688 * emulation is being done by the libc (like on AIX with JFS1). In that
689 * case we do our own emulation. fallocate implementations can
690 * return ENOTSUP or EINVAL in cases like that. */
691 ret
= SMB_VFS_FALLOCATE(fsp
, 0, offset
, num_to_write
);
692 if (ret
== -1 && errno
== ENOSPC
) {
698 DEBUG(10,("vfs_fill_sparse: SMB_VFS_FALLOCATE failed with "
699 "error %d. Falling back to slow manual allocation\n", ret
));
702 ret
= vfs_slow_fallocate(fsp
, offset
, num_to_write
);
707 set_filelen_write_cache(fsp
, len
);
710 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
714 /****************************************************************************
715 Transfer some data (n bytes) between two file_struct's.
716 ****************************************************************************/
718 static ssize_t
vfs_pread_fn(void *file
, void *buf
, size_t len
, off_t offset
)
720 struct files_struct
*fsp
= (struct files_struct
*)file
;
722 return SMB_VFS_PREAD(fsp
, buf
, len
, offset
);
725 static ssize_t
vfs_pwrite_fn(void *file
, const void *buf
, size_t len
, off_t offset
)
727 struct files_struct
*fsp
= (struct files_struct
*)file
;
729 return SMB_VFS_PWRITE(fsp
, buf
, len
, offset
);
732 off_t
vfs_transfer_file(files_struct
*in
, files_struct
*out
, off_t n
)
734 return transfer_file_internal((void *)in
, (void *)out
, n
,
735 vfs_pread_fn
, vfs_pwrite_fn
);
738 /*******************************************************************
739 A vfs_readdir wrapper which just returns the file name.
740 ********************************************************************/
742 const char *vfs_readdirname(connection_struct
*conn
, void *p
,
743 SMB_STRUCT_STAT
*sbuf
, char **talloced
)
745 struct dirent
*ptr
= NULL
;
753 ptr
= SMB_VFS_READDIR(conn
, (DIR *)p
, sbuf
);
765 #ifdef HAVE_BROKEN_READDIR_NAME
766 /* using /usr/ucb/cc is BAD */
770 status
= SMB_VFS_TRANSLATE_NAME(conn
, dname
, vfs_translate_to_windows
,
771 talloc_tos(), &translated
);
772 if (NT_STATUS_EQUAL(status
, NT_STATUS_NONE_MAPPED
)) {
776 *talloced
= translated
;
777 if (!NT_STATUS_IS_OK(status
)) {
783 /*******************************************************************
784 A wrapper for vfs_chdir().
785 ********************************************************************/
787 int vfs_ChDir(connection_struct
*conn
, const struct smb_filename
*smb_fname
)
790 struct smb_filename
*old_cwd
= conn
->cwd_fname
;
793 LastDir
= SMB_STRDUP("");
796 if (ISDOT(smb_fname
->base_name
)) {
800 if (*smb_fname
->base_name
== '/' &&
801 strcsequal(LastDir
,smb_fname
->base_name
)) {
805 DEBUG(4,("vfs_ChDir to %s\n", smb_fname
->base_name
));
807 ret
= SMB_VFS_CHDIR(conn
, smb_fname
);
813 * Always replace conn->cwd_fname. We
814 * don't know if it's been modified by
815 * VFS modules in the stack.
819 conn
->cwd_fname
= vfs_GetWd(conn
, conn
);
820 if (conn
->cwd_fname
== NULL
) {
822 * vfs_GetWd() failed.
823 * We must be able to read cwd.
824 * Return to original directory
827 int saved_errno
= errno
;
829 if (old_cwd
== NULL
) {
831 * Failed on the very first chdir()+getwd()
832 * for this connection. We can't
835 smb_panic("conn->cwd getwd failed\n");
839 /* Restore original conn->cwd_fname. */
840 conn
->cwd_fname
= old_cwd
;
842 /* Return to the previous $cwd. */
843 ret
= SMB_VFS_CHDIR(conn
, conn
->cwd_fname
);
845 smb_panic("conn->cwd getwd failed\n");
850 /* And fail the chdir(). */
854 /* vfs_GetWd() succeeded. */
855 /* Replace global cache. */
857 LastDir
= SMB_STRDUP(smb_fname
->base_name
);
859 DEBUG(4,("vfs_ChDir got %s\n", conn
->cwd_fname
->base_name
));
861 TALLOC_FREE(old_cwd
);
865 /*******************************************************************
866 Return the absolute current directory path - given a UNIX pathname.
867 Note that this path is returned in DOS format, not UNIX
868 format. Note this can be called with conn == NULL.
869 ********************************************************************/
871 struct smb_filename
*vfs_GetWd(TALLOC_CTX
*ctx
, connection_struct
*conn
)
873 struct smb_filename
*current_dir_fname
= NULL
;
875 struct smb_filename
*smb_fname_dot
= NULL
;
876 struct smb_filename
*smb_fname_full
= NULL
;
877 struct smb_filename
*result
= NULL
;
879 if (!lp_getwd_cache()) {
883 smb_fname_dot
= synthetic_smb_fname(ctx
, ".", NULL
, NULL
, 0);
884 if (smb_fname_dot
== NULL
) {
889 if (SMB_VFS_STAT(conn
, smb_fname_dot
) == -1) {
891 * Known to fail for root: the directory may be NFS-mounted
892 * and exported with root_squash (so has no root access).
894 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
895 "(NFS problem ?)\n", strerror(errno
) ));
899 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
901 smb_fname_full
= (struct smb_filename
*)memcache_lookup_talloc(
904 data_blob_const(&key
, sizeof(key
)));
906 if (smb_fname_full
== NULL
) {
910 if ((SMB_VFS_STAT(conn
, smb_fname_full
) == 0) &&
911 (smb_fname_dot
->st
.st_ex_dev
== smb_fname_full
->st
.st_ex_dev
) &&
912 (smb_fname_dot
->st
.st_ex_ino
== smb_fname_full
->st
.st_ex_ino
) &&
913 (S_ISDIR(smb_fname_dot
->st
.st_ex_mode
))) {
916 * Note: smb_fname_full is owned by smbd_memcache()
917 * so we must make a copy to return.
919 result
= cp_smb_filename(ctx
, smb_fname_full
);
920 if (result
== NULL
) {
929 * We don't have the information to hand so rely on traditional
930 * methods. The very slow getcwd, which spawns a process on some
931 * systems, or the not quite so bad getwd.
934 current_dir_fname
= SMB_VFS_GETWD(conn
, ctx
);
935 if (current_dir_fname
== NULL
) {
936 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
941 if (lp_getwd_cache() && VALID_STAT(smb_fname_dot
->st
)) {
942 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
945 * smbd_memcache() will own current_dir_fname after the
946 * memcache_add_talloc call, so we must make
947 * a copy on ctx to return.
949 result
= cp_smb_filename(ctx
, current_dir_fname
);
950 if (result
== NULL
) {
955 * Ensure the memory going into the cache
956 * doesn't have a destructor so it can be
959 talloc_set_destructor(current_dir_fname
, NULL
);
961 memcache_add_talloc(smbd_memcache(),
963 data_blob_const(&key
, sizeof(key
)),
965 /* current_dir_fname is now == NULL here. */
967 /* current_dir_fname is already allocated on ctx. */
968 result
= current_dir_fname
;
972 TALLOC_FREE(smb_fname_dot
);
974 * Don't free current_dir_fname here. It's either been moved
975 * to the memcache or is being returned in result.
980 /*******************************************************************
981 Reduce a file name, removing .. elements and checking that
982 it is below dir in the hierarchy. This uses realpath.
983 This function must run as root, and will return names
984 and valid stat structs that can be checked on open.
985 ********************************************************************/
987 NTSTATUS
check_reduced_name_with_privilege(connection_struct
*conn
,
988 const struct smb_filename
*smb_fname
,
989 struct smb_request
*smbreq
)
992 TALLOC_CTX
*ctx
= talloc_tos();
993 const char *conn_rootdir
;
995 char *dir_name
= NULL
;
996 char *resolved_name
= NULL
;
997 const char *last_component
= NULL
;
998 struct smb_filename
*resolved_fname
= NULL
;
999 struct smb_filename
*saved_dir_fname
= NULL
;
1000 struct smb_filename
*smb_fname_cwd
= NULL
;
1001 struct privilege_paths
*priv_paths
= NULL
;
1004 DEBUG(3,("check_reduced_name_with_privilege [%s] [%s]\n",
1005 smb_fname
->base_name
,
1006 conn
->connectpath
));
1009 priv_paths
= talloc_zero(smbreq
, struct privilege_paths
);
1011 status
= NT_STATUS_NO_MEMORY
;
1015 if (!parent_dirname(ctx
, smb_fname
->base_name
,
1016 &dir_name
, &last_component
)) {
1017 status
= NT_STATUS_NO_MEMORY
;
1021 priv_paths
->parent_name
.base_name
= talloc_strdup(priv_paths
, dir_name
);
1022 priv_paths
->file_name
.base_name
= talloc_strdup(priv_paths
, last_component
);
1024 if (priv_paths
->parent_name
.base_name
== NULL
||
1025 priv_paths
->file_name
.base_name
== NULL
) {
1026 status
= NT_STATUS_NO_MEMORY
;
1030 if (SMB_VFS_STAT(conn
, &priv_paths
->parent_name
) != 0) {
1031 status
= map_nt_error_from_unix(errno
);
1034 /* Remember where we were. */
1035 saved_dir_fname
= vfs_GetWd(ctx
, conn
);
1036 if (!saved_dir_fname
) {
1037 status
= map_nt_error_from_unix(errno
);
1041 if (vfs_ChDir(conn
, &priv_paths
->parent_name
) == -1) {
1042 status
= map_nt_error_from_unix(errno
);
1046 smb_fname_cwd
= synthetic_smb_fname(talloc_tos(), ".", NULL
, NULL
, 0);
1047 if (smb_fname_cwd
== NULL
) {
1048 status
= NT_STATUS_NO_MEMORY
;
1052 /* Get the absolute path of the parent directory. */
1053 resolved_fname
= SMB_VFS_REALPATH(conn
, ctx
, smb_fname_cwd
);
1054 if (resolved_fname
== NULL
) {
1055 status
= map_nt_error_from_unix(errno
);
1058 resolved_name
= resolved_fname
->base_name
;
1060 if (*resolved_name
!= '/') {
1061 DEBUG(0,("check_reduced_name_with_privilege: realpath "
1062 "doesn't return absolute paths !\n"));
1063 status
= NT_STATUS_OBJECT_NAME_INVALID
;
1067 DEBUG(10,("check_reduced_name_with_privilege: realpath [%s] -> [%s]\n",
1068 priv_paths
->parent_name
.base_name
,
1071 /* Now check the stat value is the same. */
1072 if (SMB_VFS_LSTAT(conn
, smb_fname_cwd
) != 0) {
1073 status
= map_nt_error_from_unix(errno
);
1077 /* Ensure we're pointing at the same place. */
1078 if (!check_same_stat(&smb_fname_cwd
->st
, &priv_paths
->parent_name
.st
)) {
1079 DEBUG(0,("check_reduced_name_with_privilege: "
1080 "device/inode/uid/gid on directory %s changed. "
1081 "Denying access !\n",
1082 priv_paths
->parent_name
.base_name
));
1083 status
= NT_STATUS_ACCESS_DENIED
;
1087 /* Ensure we're below the connect path. */
1089 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, smb_fname
);
1090 if (conn_rootdir
== NULL
) {
1091 DEBUG(2, ("check_reduced_name_with_privilege: Could not get "
1093 status
= NT_STATUS_ACCESS_DENIED
;
1097 rootdir_len
= strlen(conn_rootdir
);
1100 * In the case of rootdir_len == 1, we know that conn_rootdir is
1101 * "/", and we also know that resolved_name starts with a slash.
1102 * So, in this corner case, resolved_name is automatically a
1103 * sub-directory of the conn_rootdir. Thus we can skip the string
1104 * comparison and the next character checks (which are even
1105 * wrong in this case).
1107 if (rootdir_len
!= 1) {
1110 matched
= (strncmp(conn_rootdir
, resolved_name
,
1113 if (!matched
|| (resolved_name
[rootdir_len
] != '/' &&
1114 resolved_name
[rootdir_len
] != '\0')) {
1115 DEBUG(2, ("check_reduced_name_with_privilege: Bad "
1116 "access attempt: %s is a symlink outside the "
1119 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir
));
1120 DEBUGADD(2, ("resolved_name=%s\n", resolved_name
));
1121 status
= NT_STATUS_ACCESS_DENIED
;
1126 /* Now ensure that the last component either doesn't
1127 exist, or is *NOT* a symlink. */
1129 ret
= SMB_VFS_LSTAT(conn
, &priv_paths
->file_name
);
1131 /* Errno must be ENOENT for this be ok. */
1132 if (errno
!= ENOENT
) {
1133 status
= map_nt_error_from_unix(errno
);
1134 DEBUG(2, ("check_reduced_name_with_privilege: "
1135 "LSTAT on %s failed with %s\n",
1136 priv_paths
->file_name
.base_name
,
1137 nt_errstr(status
)));
1142 if (VALID_STAT(priv_paths
->file_name
.st
) &&
1143 S_ISLNK(priv_paths
->file_name
.st
.st_ex_mode
)) {
1144 DEBUG(2, ("check_reduced_name_with_privilege: "
1145 "Last component %s is a symlink. Denying"
1147 priv_paths
->file_name
.base_name
));
1148 status
= NT_STATUS_ACCESS_DENIED
;
1152 smbreq
->priv_paths
= priv_paths
;
1153 status
= NT_STATUS_OK
;
1157 if (saved_dir_fname
!= NULL
) {
1158 vfs_ChDir(conn
, saved_dir_fname
);
1159 TALLOC_FREE(saved_dir_fname
);
1161 TALLOC_FREE(resolved_fname
);
1162 if (!NT_STATUS_IS_OK(status
)) {
1163 TALLOC_FREE(priv_paths
);
1165 TALLOC_FREE(dir_name
);
1169 /*******************************************************************
1170 Reduce a file name, removing .. elements and checking that
1171 it is below dir in the hierarchy. This uses realpath.
1173 If cwd_name == NULL then fname is a client given path relative
1174 to the root path of the share.
1176 If cwd_name != NULL then fname is a client given path relative
1177 to cwd_name. cwd_name is relative to the root path of the share.
1178 ********************************************************************/
1180 NTSTATUS
check_reduced_name(connection_struct
*conn
,
1181 const struct smb_filename
*cwd_fname
,
1182 const struct smb_filename
*smb_fname
)
1184 TALLOC_CTX
*ctx
= talloc_tos();
1185 const char *cwd_name
= cwd_fname
? cwd_fname
->base_name
: NULL
;
1186 const char *fname
= smb_fname
->base_name
;
1187 struct smb_filename
*resolved_fname
;
1188 char *resolved_name
= NULL
;
1189 char *new_fname
= NULL
;
1190 bool allow_symlinks
= true;
1191 bool allow_widelinks
= false;
1193 DBG_DEBUG("check_reduced_name [%s] [%s]\n", fname
, conn
->connectpath
);
1195 resolved_fname
= SMB_VFS_REALPATH(conn
, ctx
, smb_fname
);
1197 if (resolved_fname
== NULL
) {
1200 DEBUG(3,("check_reduced_name: Component not a "
1201 "directory in getting realpath for "
1203 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1206 char *dir_name
= NULL
;
1207 struct smb_filename dir_fname
= {0};
1208 const char *last_component
= NULL
;
1210 /* Last component didn't exist.
1211 Remove it and try and canonicalise
1212 the directory name. */
1213 if (!parent_dirname(ctx
, fname
,
1216 return NT_STATUS_NO_MEMORY
;
1219 dir_fname
= (struct smb_filename
)
1220 { .base_name
= dir_name
};
1221 resolved_fname
= SMB_VFS_REALPATH(conn
,
1224 if (resolved_fname
== NULL
) {
1225 NTSTATUS status
= map_nt_error_from_unix(errno
);
1227 if (errno
== ENOENT
|| errno
== ENOTDIR
) {
1228 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
1231 DEBUG(3,("check_reduce_name: "
1232 "couldn't get realpath for "
1235 nt_errstr(status
)));
1238 resolved_name
= talloc_asprintf(ctx
,
1240 resolved_fname
->base_name
,
1242 if (resolved_name
== NULL
) {
1243 return NT_STATUS_NO_MEMORY
;
1248 DEBUG(3,("check_reduced_name: couldn't get "
1249 "realpath for %s\n", fname
));
1250 return map_nt_error_from_unix(errno
);
1253 resolved_name
= resolved_fname
->base_name
;
1256 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname
,
1259 if (*resolved_name
!= '/') {
1260 DEBUG(0,("check_reduced_name: realpath doesn't return "
1261 "absolute paths !\n"));
1262 TALLOC_FREE(resolved_fname
);
1263 return NT_STATUS_OBJECT_NAME_INVALID
;
1266 allow_widelinks
= lp_widelinks(SNUM(conn
));
1267 allow_symlinks
= lp_follow_symlinks(SNUM(conn
));
1269 /* Common widelinks and symlinks checks. */
1270 if (!allow_widelinks
|| !allow_symlinks
) {
1271 const char *conn_rootdir
;
1274 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, smb_fname
);
1275 if (conn_rootdir
== NULL
) {
1276 DEBUG(2, ("check_reduced_name: Could not get "
1278 TALLOC_FREE(resolved_fname
);
1279 return NT_STATUS_ACCESS_DENIED
;
1282 rootdir_len
= strlen(conn_rootdir
);
1285 * In the case of rootdir_len == 1, we know that
1286 * conn_rootdir is "/", and we also know that
1287 * resolved_name starts with a slash. So, in this
1288 * corner case, resolved_name is automatically a
1289 * sub-directory of the conn_rootdir. Thus we can skip
1290 * the string comparison and the next character checks
1291 * (which are even wrong in this case).
1293 if (rootdir_len
!= 1) {
1296 matched
= (strncmp(conn_rootdir
, resolved_name
,
1298 if (!matched
|| (resolved_name
[rootdir_len
] != '/' &&
1299 resolved_name
[rootdir_len
] != '\0')) {
1300 DEBUG(2, ("check_reduced_name: Bad access "
1301 "attempt: %s is a symlink outside the "
1302 "share path\n", fname
));
1303 DEBUGADD(2, ("conn_rootdir =%s\n",
1305 DEBUGADD(2, ("resolved_name=%s\n",
1307 TALLOC_FREE(resolved_fname
);
1308 return NT_STATUS_ACCESS_DENIED
;
1312 /* Extra checks if all symlinks are disallowed. */
1313 if (!allow_symlinks
) {
1314 /* fname can't have changed in resolved_path. */
1315 const char *p
= &resolved_name
[rootdir_len
];
1318 * UNIX filesystem semantics, names consisting
1319 * only of "." or ".." CANNOT be symlinks.
1321 if (ISDOT(fname
) || ISDOTDOT(fname
)) {
1326 DEBUG(2, ("check_reduced_name: logic error (%c) "
1327 "in resolved_name: %s\n",
1330 TALLOC_FREE(resolved_fname
);
1331 return NT_STATUS_ACCESS_DENIED
;
1337 * If cwd_name is present and not ".",
1338 * then fname is relative to that, not
1339 * the root of the share. Make sure the
1340 * path we check is the one the client
1341 * sent (cwd_name+fname).
1343 if (cwd_name
!= NULL
&& !ISDOT(cwd_name
)) {
1344 new_fname
= talloc_asprintf(ctx
,
1348 if (new_fname
== NULL
) {
1349 TALLOC_FREE(resolved_fname
);
1350 return NT_STATUS_NO_MEMORY
;
1355 if (strcmp(fname
, p
)!=0) {
1356 DEBUG(2, ("check_reduced_name: Bad access "
1357 "attempt: %s is a symlink to %s\n",
1359 TALLOC_FREE(resolved_fname
);
1360 TALLOC_FREE(new_fname
);
1361 return NT_STATUS_ACCESS_DENIED
;
1368 DBG_INFO("%s reduced to %s\n", fname
, resolved_name
);
1369 TALLOC_FREE(resolved_fname
);
1370 TALLOC_FREE(new_fname
);
1371 return NT_STATUS_OK
;
1375 * XXX: This is temporary and there should be no callers of this once
1376 * smb_filename is plumbed through all path based operations.
1378 * Called when we know stream name parsing has already been done.
1380 int vfs_stat_smb_basename(struct connection_struct
*conn
,
1381 const struct smb_filename
*smb_fname_in
,
1382 SMB_STRUCT_STAT
*psbuf
)
1384 struct smb_filename smb_fname
= {
1385 .base_name
= discard_const_p(char, smb_fname_in
->base_name
),
1386 .flags
= smb_fname_in
->flags
1390 if (smb_fname
.flags
& SMB_FILENAME_POSIX_PATH
) {
1391 ret
= SMB_VFS_LSTAT(conn
, &smb_fname
);
1393 ret
= SMB_VFS_STAT(conn
, &smb_fname
);
1397 *psbuf
= smb_fname
.st
;
1403 * Ensure LSTAT is called for POSIX paths.
1406 NTSTATUS
vfs_stat_fsp(files_struct
*fsp
)
1410 if(fsp
->fh
->fd
== -1) {
1411 if (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) {
1412 ret
= SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1414 ret
= SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1417 return map_nt_error_from_unix(errno
);
1420 if(SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) != 0) {
1421 return map_nt_error_from_unix(errno
);
1424 return NT_STATUS_OK
;
1428 * Initialize num_streams and streams, then call VFS op streaminfo
1430 NTSTATUS
vfs_streaminfo(connection_struct
*conn
,
1431 struct files_struct
*fsp
,
1432 const struct smb_filename
*smb_fname
,
1433 TALLOC_CTX
*mem_ctx
,
1434 unsigned int *num_streams
,
1435 struct stream_struct
**streams
)
1439 return SMB_VFS_STREAMINFO(conn
,
1448 generate a file_id from a stat structure
1450 struct file_id
vfs_file_id_from_sbuf(connection_struct
*conn
, const SMB_STRUCT_STAT
*sbuf
)
1452 return SMB_VFS_FILE_ID_CREATE(conn
, sbuf
);
1455 int smb_vfs_call_connect(struct vfs_handle_struct
*handle
,
1456 const char *service
, const char *user
)
1459 return handle
->fns
->connect_fn(handle
, service
, user
);
1462 void smb_vfs_call_disconnect(struct vfs_handle_struct
*handle
)
1464 VFS_FIND(disconnect
);
1465 handle
->fns
->disconnect_fn(handle
);
1468 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct
*handle
,
1469 const struct smb_filename
*smb_fname
,
1474 VFS_FIND(disk_free
);
1475 return handle
->fns
->disk_free_fn(handle
, smb_fname
,
1476 bsize
, dfree
, dsize
);
1479 int smb_vfs_call_get_quota(struct vfs_handle_struct
*handle
,
1480 const struct smb_filename
*smb_fname
,
1481 enum SMB_QUOTA_TYPE qtype
,
1485 VFS_FIND(get_quota
);
1486 return handle
->fns
->get_quota_fn(handle
, smb_fname
, qtype
, id
, qt
);
1489 int smb_vfs_call_set_quota(struct vfs_handle_struct
*handle
,
1490 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1493 VFS_FIND(set_quota
);
1494 return handle
->fns
->set_quota_fn(handle
, qtype
, id
, qt
);
1497 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
1498 struct files_struct
*fsp
,
1499 struct shadow_copy_data
*shadow_copy_data
,
1502 VFS_FIND(get_shadow_copy_data
);
1503 return handle
->fns
->get_shadow_copy_data_fn(handle
, fsp
,
1507 int smb_vfs_call_statvfs(struct vfs_handle_struct
*handle
,
1508 const struct smb_filename
*smb_fname
,
1509 struct vfs_statvfs_struct
*statbuf
)
1512 return handle
->fns
->statvfs_fn(handle
, smb_fname
, statbuf
);
1515 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct
*handle
,
1516 enum timestamp_set_resolution
*p_ts_res
)
1518 VFS_FIND(fs_capabilities
);
1519 return handle
->fns
->fs_capabilities_fn(handle
, p_ts_res
);
1522 NTSTATUS
smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct
*handle
,
1523 struct dfs_GetDFSReferral
*r
)
1525 VFS_FIND(get_dfs_referrals
);
1526 return handle
->fns
->get_dfs_referrals_fn(handle
, r
);
1529 DIR *smb_vfs_call_opendir(struct vfs_handle_struct
*handle
,
1530 const struct smb_filename
*smb_fname
,
1532 uint32_t attributes
)
1535 return handle
->fns
->opendir_fn(handle
, smb_fname
, mask
, attributes
);
1538 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct
*handle
,
1539 struct files_struct
*fsp
,
1541 uint32_t attributes
)
1543 VFS_FIND(fdopendir
);
1544 return handle
->fns
->fdopendir_fn(handle
, fsp
, mask
, attributes
);
1547 struct dirent
*smb_vfs_call_readdir(struct vfs_handle_struct
*handle
,
1549 SMB_STRUCT_STAT
*sbuf
)
1552 return handle
->fns
->readdir_fn(handle
, dirp
, sbuf
);
1555 void smb_vfs_call_seekdir(struct vfs_handle_struct
*handle
,
1556 DIR *dirp
, long offset
)
1559 handle
->fns
->seekdir_fn(handle
, dirp
, offset
);
1562 long smb_vfs_call_telldir(struct vfs_handle_struct
*handle
,
1566 return handle
->fns
->telldir_fn(handle
, dirp
);
1569 void smb_vfs_call_rewind_dir(struct vfs_handle_struct
*handle
,
1572 VFS_FIND(rewind_dir
);
1573 handle
->fns
->rewind_dir_fn(handle
, dirp
);
1576 int smb_vfs_call_mkdir(struct vfs_handle_struct
*handle
,
1577 const struct smb_filename
*smb_fname
,
1581 return handle
->fns
->mkdir_fn(handle
, smb_fname
, mode
);
1584 int smb_vfs_call_rmdir(struct vfs_handle_struct
*handle
,
1585 const struct smb_filename
*smb_fname
)
1588 return handle
->fns
->rmdir_fn(handle
, smb_fname
);
1591 int smb_vfs_call_closedir(struct vfs_handle_struct
*handle
,
1595 return handle
->fns
->closedir_fn(handle
, dir
);
1598 int smb_vfs_call_open(struct vfs_handle_struct
*handle
,
1599 struct smb_filename
*smb_fname
, struct files_struct
*fsp
,
1600 int flags
, mode_t mode
)
1603 return handle
->fns
->open_fn(handle
, smb_fname
, fsp
, flags
, mode
);
1606 NTSTATUS
smb_vfs_call_create_file(struct vfs_handle_struct
*handle
,
1607 struct smb_request
*req
,
1608 uint16_t root_dir_fid
,
1609 struct smb_filename
*smb_fname
,
1610 uint32_t access_mask
,
1611 uint32_t share_access
,
1612 uint32_t create_disposition
,
1613 uint32_t create_options
,
1614 uint32_t file_attributes
,
1615 uint32_t oplock_request
,
1616 struct smb2_lease
*lease
,
1617 uint64_t allocation_size
,
1618 uint32_t private_flags
,
1619 struct security_descriptor
*sd
,
1620 struct ea_list
*ea_list
,
1621 files_struct
**result
,
1623 const struct smb2_create_blobs
*in_context_blobs
,
1624 struct smb2_create_blobs
*out_context_blobs
)
1626 VFS_FIND(create_file
);
1627 return handle
->fns
->create_file_fn(
1628 handle
, req
, root_dir_fid
, smb_fname
, access_mask
,
1629 share_access
, create_disposition
, create_options
,
1630 file_attributes
, oplock_request
, lease
, allocation_size
,
1631 private_flags
, sd
, ea_list
,
1632 result
, pinfo
, in_context_blobs
, out_context_blobs
);
1635 int smb_vfs_call_close(struct vfs_handle_struct
*handle
,
1636 struct files_struct
*fsp
)
1639 return handle
->fns
->close_fn(handle
, fsp
);
1642 ssize_t
smb_vfs_call_pread(struct vfs_handle_struct
*handle
,
1643 struct files_struct
*fsp
, void *data
, size_t n
,
1647 return handle
->fns
->pread_fn(handle
, fsp
, data
, n
, offset
);
1650 struct smb_vfs_call_pread_state
{
1651 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1653 struct vfs_aio_state vfs_aio_state
;
1656 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
);
1658 struct tevent_req
*smb_vfs_call_pread_send(struct vfs_handle_struct
*handle
,
1659 TALLOC_CTX
*mem_ctx
,
1660 struct tevent_context
*ev
,
1661 struct files_struct
*fsp
,
1663 size_t n
, off_t offset
)
1665 struct tevent_req
*req
, *subreq
;
1666 struct smb_vfs_call_pread_state
*state
;
1668 req
= tevent_req_create(mem_ctx
, &state
,
1669 struct smb_vfs_call_pread_state
);
1673 VFS_FIND(pread_send
);
1674 state
->recv_fn
= handle
->fns
->pread_recv_fn
;
1676 subreq
= handle
->fns
->pread_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1678 if (tevent_req_nomem(subreq
, req
)) {
1679 return tevent_req_post(req
, ev
);
1681 tevent_req_set_callback(subreq
, smb_vfs_call_pread_done
, req
);
1685 static void smb_vfs_call_pread_done(struct tevent_req
*subreq
)
1687 struct tevent_req
*req
= tevent_req_callback_data(
1688 subreq
, struct tevent_req
);
1689 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1690 req
, struct smb_vfs_call_pread_state
);
1692 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1693 TALLOC_FREE(subreq
);
1694 if (state
->retval
== -1) {
1695 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1698 tevent_req_done(req
);
1701 ssize_t
SMB_VFS_PREAD_RECV(struct tevent_req
*req
,
1702 struct vfs_aio_state
*vfs_aio_state
)
1704 struct smb_vfs_call_pread_state
*state
= tevent_req_data(
1705 req
, struct smb_vfs_call_pread_state
);
1708 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1709 tevent_req_received(req
);
1712 *vfs_aio_state
= state
->vfs_aio_state
;
1713 retval
= state
->retval
;
1714 tevent_req_received(req
);
1718 ssize_t
smb_vfs_call_pwrite(struct vfs_handle_struct
*handle
,
1719 struct files_struct
*fsp
, const void *data
,
1720 size_t n
, off_t offset
)
1723 return handle
->fns
->pwrite_fn(handle
, fsp
, data
, n
, offset
);
1726 struct smb_vfs_call_pwrite_state
{
1727 ssize_t (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1729 struct vfs_aio_state vfs_aio_state
;
1732 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
);
1734 struct tevent_req
*smb_vfs_call_pwrite_send(struct vfs_handle_struct
*handle
,
1735 TALLOC_CTX
*mem_ctx
,
1736 struct tevent_context
*ev
,
1737 struct files_struct
*fsp
,
1739 size_t n
, off_t offset
)
1741 struct tevent_req
*req
, *subreq
;
1742 struct smb_vfs_call_pwrite_state
*state
;
1744 req
= tevent_req_create(mem_ctx
, &state
,
1745 struct smb_vfs_call_pwrite_state
);
1749 VFS_FIND(pwrite_send
);
1750 state
->recv_fn
= handle
->fns
->pwrite_recv_fn
;
1752 subreq
= handle
->fns
->pwrite_send_fn(handle
, state
, ev
, fsp
, data
, n
,
1754 if (tevent_req_nomem(subreq
, req
)) {
1755 return tevent_req_post(req
, ev
);
1757 tevent_req_set_callback(subreq
, smb_vfs_call_pwrite_done
, req
);
1761 static void smb_vfs_call_pwrite_done(struct tevent_req
*subreq
)
1763 struct tevent_req
*req
= tevent_req_callback_data(
1764 subreq
, struct tevent_req
);
1765 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1766 req
, struct smb_vfs_call_pwrite_state
);
1768 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1769 TALLOC_FREE(subreq
);
1770 if (state
->retval
== -1) {
1771 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1774 tevent_req_done(req
);
1777 ssize_t
SMB_VFS_PWRITE_RECV(struct tevent_req
*req
,
1778 struct vfs_aio_state
*vfs_aio_state
)
1780 struct smb_vfs_call_pwrite_state
*state
= tevent_req_data(
1781 req
, struct smb_vfs_call_pwrite_state
);
1784 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1785 tevent_req_received(req
);
1788 *vfs_aio_state
= state
->vfs_aio_state
;
1789 retval
= state
->retval
;
1790 tevent_req_received(req
);
1794 off_t
smb_vfs_call_lseek(struct vfs_handle_struct
*handle
,
1795 struct files_struct
*fsp
, off_t offset
,
1799 return handle
->fns
->lseek_fn(handle
, fsp
, offset
, whence
);
1802 ssize_t
smb_vfs_call_sendfile(struct vfs_handle_struct
*handle
, int tofd
,
1803 files_struct
*fromfsp
, const DATA_BLOB
*header
,
1804 off_t offset
, size_t count
)
1807 return handle
->fns
->sendfile_fn(handle
, tofd
, fromfsp
, header
, offset
,
1811 ssize_t
smb_vfs_call_recvfile(struct vfs_handle_struct
*handle
, int fromfd
,
1812 files_struct
*tofsp
, off_t offset
,
1816 return handle
->fns
->recvfile_fn(handle
, fromfd
, tofsp
, offset
, count
);
1819 int smb_vfs_call_rename(struct vfs_handle_struct
*handle
,
1820 const struct smb_filename
*smb_fname_src
,
1821 const struct smb_filename
*smb_fname_dst
)
1824 return handle
->fns
->rename_fn(handle
, smb_fname_src
, smb_fname_dst
);
1827 struct smb_vfs_call_fsync_state
{
1828 int (*recv_fn
)(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
);
1830 struct vfs_aio_state vfs_aio_state
;
1833 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
);
1835 struct tevent_req
*smb_vfs_call_fsync_send(struct vfs_handle_struct
*handle
,
1836 TALLOC_CTX
*mem_ctx
,
1837 struct tevent_context
*ev
,
1838 struct files_struct
*fsp
)
1840 struct tevent_req
*req
, *subreq
;
1841 struct smb_vfs_call_fsync_state
*state
;
1843 req
= tevent_req_create(mem_ctx
, &state
,
1844 struct smb_vfs_call_fsync_state
);
1848 VFS_FIND(fsync_send
);
1849 state
->recv_fn
= handle
->fns
->fsync_recv_fn
;
1851 subreq
= handle
->fns
->fsync_send_fn(handle
, state
, ev
, fsp
);
1852 if (tevent_req_nomem(subreq
, req
)) {
1853 return tevent_req_post(req
, ev
);
1855 tevent_req_set_callback(subreq
, smb_vfs_call_fsync_done
, req
);
1859 static void smb_vfs_call_fsync_done(struct tevent_req
*subreq
)
1861 struct tevent_req
*req
= tevent_req_callback_data(
1862 subreq
, struct tevent_req
);
1863 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1864 req
, struct smb_vfs_call_fsync_state
);
1866 state
->retval
= state
->recv_fn(subreq
, &state
->vfs_aio_state
);
1867 TALLOC_FREE(subreq
);
1868 if (state
->retval
== -1) {
1869 tevent_req_error(req
, state
->vfs_aio_state
.error
);
1872 tevent_req_done(req
);
1875 int SMB_VFS_FSYNC_RECV(struct tevent_req
*req
, struct vfs_aio_state
*vfs_aio_state
)
1877 struct smb_vfs_call_fsync_state
*state
= tevent_req_data(
1878 req
, struct smb_vfs_call_fsync_state
);
1881 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
1882 tevent_req_received(req
);
1885 *vfs_aio_state
= state
->vfs_aio_state
;
1886 retval
= state
->retval
;
1887 tevent_req_received(req
);
1892 * Synchronous version of fsync, built from backend
1893 * async VFS primitives. Uses a temporary sub-event
1894 * context (NOT NESTED).
1897 int smb_vfs_fsync_sync(files_struct
*fsp
)
1899 TALLOC_CTX
*frame
= talloc_stackframe();
1900 struct tevent_req
*req
= NULL
;
1901 struct vfs_aio_state aio_state
= { 0 };
1904 struct tevent_context
*ev
= samba_tevent_context_init(frame
);
1910 req
= SMB_VFS_FSYNC_SEND(talloc_tos(), ev
, fsp
);
1915 ok
= tevent_req_poll(req
, ev
);
1920 ret
= SMB_VFS_FSYNC_RECV(req
, &aio_state
);
1925 if (aio_state
.error
!= 0) {
1926 errno
= aio_state
.error
;
1931 int smb_vfs_call_stat(struct vfs_handle_struct
*handle
,
1932 struct smb_filename
*smb_fname
)
1935 return handle
->fns
->stat_fn(handle
, smb_fname
);
1938 int smb_vfs_call_fstat(struct vfs_handle_struct
*handle
,
1939 struct files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
1942 return handle
->fns
->fstat_fn(handle
, fsp
, sbuf
);
1945 int smb_vfs_call_lstat(struct vfs_handle_struct
*handle
,
1946 struct smb_filename
*smb_filename
)
1949 return handle
->fns
->lstat_fn(handle
, smb_filename
);
1952 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct
*handle
,
1953 struct files_struct
*fsp
,
1954 const SMB_STRUCT_STAT
*sbuf
)
1956 VFS_FIND(get_alloc_size
);
1957 return handle
->fns
->get_alloc_size_fn(handle
, fsp
, sbuf
);
1960 int smb_vfs_call_unlink(struct vfs_handle_struct
*handle
,
1961 const struct smb_filename
*smb_fname
)
1964 return handle
->fns
->unlink_fn(handle
, smb_fname
);
1967 int smb_vfs_call_chmod(struct vfs_handle_struct
*handle
,
1968 const struct smb_filename
*smb_fname
,
1972 return handle
->fns
->chmod_fn(handle
, smb_fname
, mode
);
1975 int smb_vfs_call_fchmod(struct vfs_handle_struct
*handle
,
1976 struct files_struct
*fsp
, mode_t mode
)
1979 return handle
->fns
->fchmod_fn(handle
, fsp
, mode
);
1982 int smb_vfs_call_chown(struct vfs_handle_struct
*handle
,
1983 const struct smb_filename
*smb_fname
,
1988 return handle
->fns
->chown_fn(handle
, smb_fname
, uid
, gid
);
1991 int smb_vfs_call_fchown(struct vfs_handle_struct
*handle
,
1992 struct files_struct
*fsp
, uid_t uid
, gid_t gid
)
1995 return handle
->fns
->fchown_fn(handle
, fsp
, uid
, gid
);
1998 int smb_vfs_call_lchown(struct vfs_handle_struct
*handle
,
1999 const struct smb_filename
*smb_fname
,
2004 return handle
->fns
->lchown_fn(handle
, smb_fname
, uid
, gid
);
2007 NTSTATUS
vfs_chown_fsp(files_struct
*fsp
, uid_t uid
, gid_t gid
)
2010 bool as_root
= false;
2013 if (fsp
->fh
->fd
!= -1) {
2015 ret
= SMB_VFS_FCHOWN(fsp
, uid
, gid
);
2017 return NT_STATUS_OK
;
2019 if (ret
== -1 && errno
!= ENOSYS
) {
2020 return map_nt_error_from_unix(errno
);
2024 as_root
= (geteuid() == 0);
2028 * We are being asked to chown as root. Make
2029 * sure we chdir() into the path to pin it,
2030 * and always act using lchown to ensure we
2031 * don't deref any symbolic links.
2033 char *parent_dir
= NULL
;
2034 const char *final_component
= NULL
;
2035 struct smb_filename
*local_smb_fname
= NULL
;
2036 struct smb_filename parent_dir_fname
= {0};
2037 struct smb_filename
*saved_dir_fname
= NULL
;
2039 saved_dir_fname
= vfs_GetWd(talloc_tos(),fsp
->conn
);
2040 if (!saved_dir_fname
) {
2041 status
= map_nt_error_from_unix(errno
);
2042 DEBUG(0,("vfs_chown_fsp: failed to get "
2043 "current working directory. Error was %s\n",
2048 if (!parent_dirname(talloc_tos(),
2049 fsp
->fsp_name
->base_name
,
2051 &final_component
)) {
2052 return NT_STATUS_NO_MEMORY
;
2055 parent_dir_fname
= (struct smb_filename
) {
2056 .base_name
= parent_dir
,
2057 .flags
= fsp
->fsp_name
->flags
2060 /* cd into the parent dir to pin it. */
2061 ret
= vfs_ChDir(fsp
->conn
, &parent_dir_fname
);
2063 return map_nt_error_from_unix(errno
);
2066 local_smb_fname
= synthetic_smb_fname(talloc_tos(),
2070 fsp
->fsp_name
->flags
);
2071 if (local_smb_fname
== NULL
) {
2072 status
= NT_STATUS_NO_MEMORY
;
2076 /* Must use lstat here. */
2077 ret
= SMB_VFS_LSTAT(fsp
->conn
, local_smb_fname
);
2079 status
= map_nt_error_from_unix(errno
);
2083 /* Ensure it matches the fsp stat. */
2084 if (!check_same_stat(&local_smb_fname
->st
,
2085 &fsp
->fsp_name
->st
)) {
2086 status
= NT_STATUS_ACCESS_DENIED
;
2090 ret
= SMB_VFS_LCHOWN(fsp
->conn
,
2095 status
= NT_STATUS_OK
;
2097 status
= map_nt_error_from_unix(errno
);
2102 vfs_ChDir(fsp
->conn
, saved_dir_fname
);
2103 TALLOC_FREE(local_smb_fname
);
2104 TALLOC_FREE(saved_dir_fname
);
2105 TALLOC_FREE(parent_dir
);
2110 if (fsp
->posix_flags
& FSP_POSIX_FLAGS_OPEN
) {
2111 ret
= SMB_VFS_LCHOWN(fsp
->conn
,
2115 ret
= SMB_VFS_CHOWN(fsp
->conn
,
2121 status
= NT_STATUS_OK
;
2123 status
= map_nt_error_from_unix(errno
);
2128 int smb_vfs_call_chdir(struct vfs_handle_struct
*handle
,
2129 const struct smb_filename
*smb_fname
)
2132 return handle
->fns
->chdir_fn(handle
, smb_fname
);
2135 struct smb_filename
*smb_vfs_call_getwd(struct vfs_handle_struct
*handle
,
2139 return handle
->fns
->getwd_fn(handle
, ctx
);
2142 int smb_vfs_call_ntimes(struct vfs_handle_struct
*handle
,
2143 const struct smb_filename
*smb_fname
,
2144 struct smb_file_time
*ft
)
2147 return handle
->fns
->ntimes_fn(handle
, smb_fname
, ft
);
2150 int smb_vfs_call_ftruncate(struct vfs_handle_struct
*handle
,
2151 struct files_struct
*fsp
, off_t offset
)
2153 VFS_FIND(ftruncate
);
2154 return handle
->fns
->ftruncate_fn(handle
, fsp
, offset
);
2157 int smb_vfs_call_fallocate(struct vfs_handle_struct
*handle
,
2158 struct files_struct
*fsp
,
2163 VFS_FIND(fallocate
);
2164 return handle
->fns
->fallocate_fn(handle
, fsp
, mode
, offset
, len
);
2167 int smb_vfs_call_kernel_flock(struct vfs_handle_struct
*handle
,
2168 struct files_struct
*fsp
, uint32_t share_mode
,
2169 uint32_t access_mask
)
2171 VFS_FIND(kernel_flock
);
2172 return handle
->fns
->kernel_flock_fn(handle
, fsp
, share_mode
,
2176 int smb_vfs_call_linux_setlease(struct vfs_handle_struct
*handle
,
2177 struct files_struct
*fsp
, int leasetype
)
2179 VFS_FIND(linux_setlease
);
2180 return handle
->fns
->linux_setlease_fn(handle
, fsp
, leasetype
);
2183 int smb_vfs_call_symlink(struct vfs_handle_struct
*handle
,
2184 const char *link_target
,
2185 const struct smb_filename
*new_smb_fname
)
2188 return handle
->fns
->symlink_fn(handle
, link_target
, new_smb_fname
);
2191 int smb_vfs_call_readlink(struct vfs_handle_struct
*handle
,
2192 const struct smb_filename
*smb_fname
,
2197 return handle
->fns
->readlink_fn(handle
, smb_fname
, buf
, bufsiz
);
2200 int smb_vfs_call_link(struct vfs_handle_struct
*handle
,
2201 const struct smb_filename
*old_smb_fname
,
2202 const struct smb_filename
*new_smb_fname
)
2205 return handle
->fns
->link_fn(handle
, old_smb_fname
, new_smb_fname
);
2208 int smb_vfs_call_mknod(struct vfs_handle_struct
*handle
,
2209 const struct smb_filename
*smb_fname
,
2214 return handle
->fns
->mknod_fn(handle
, smb_fname
, mode
, dev
);
2217 struct smb_filename
*smb_vfs_call_realpath(struct vfs_handle_struct
*handle
,
2219 const struct smb_filename
*smb_fname
)
2222 return handle
->fns
->realpath_fn(handle
, ctx
, smb_fname
);
2225 int smb_vfs_call_chflags(struct vfs_handle_struct
*handle
,
2226 const struct smb_filename
*smb_fname
,
2230 return handle
->fns
->chflags_fn(handle
, smb_fname
, flags
);
2233 struct file_id
smb_vfs_call_file_id_create(struct vfs_handle_struct
*handle
,
2234 const SMB_STRUCT_STAT
*sbuf
)
2236 VFS_FIND(file_id_create
);
2237 return handle
->fns
->file_id_create_fn(handle
, sbuf
);
2240 NTSTATUS
smb_vfs_call_streaminfo(struct vfs_handle_struct
*handle
,
2241 struct files_struct
*fsp
,
2242 const struct smb_filename
*smb_fname
,
2243 TALLOC_CTX
*mem_ctx
,
2244 unsigned int *num_streams
,
2245 struct stream_struct
**streams
)
2247 VFS_FIND(streaminfo
);
2248 return handle
->fns
->streaminfo_fn(handle
, fsp
, smb_fname
, mem_ctx
,
2249 num_streams
, streams
);
2252 int smb_vfs_call_get_real_filename(struct vfs_handle_struct
*handle
,
2253 const char *path
, const char *name
,
2254 TALLOC_CTX
*mem_ctx
, char **found_name
)
2256 VFS_FIND(get_real_filename
);
2257 return handle
->fns
->get_real_filename_fn(handle
, path
, name
, mem_ctx
,
2261 const char *smb_vfs_call_connectpath(struct vfs_handle_struct
*handle
,
2262 const struct smb_filename
*smb_fname
)
2264 VFS_FIND(connectpath
);
2265 return handle
->fns
->connectpath_fn(handle
, smb_fname
);
2268 bool smb_vfs_call_strict_lock_check(struct vfs_handle_struct
*handle
,
2269 struct files_struct
*fsp
,
2270 struct lock_struct
*plock
)
2272 VFS_FIND(strict_lock_check
);
2273 return handle
->fns
->strict_lock_check_fn(handle
, fsp
, plock
);
2276 NTSTATUS
smb_vfs_call_translate_name(struct vfs_handle_struct
*handle
,
2278 enum vfs_translate_direction direction
,
2279 TALLOC_CTX
*mem_ctx
,
2282 VFS_FIND(translate_name
);
2283 return handle
->fns
->translate_name_fn(handle
, name
, direction
, mem_ctx
,
2287 NTSTATUS
smb_vfs_call_fsctl(struct vfs_handle_struct
*handle
,
2288 struct files_struct
*fsp
,
2292 const uint8_t *in_data
,
2295 uint32_t max_out_len
,
2299 return handle
->fns
->fsctl_fn(handle
, fsp
, ctx
, function
, req_flags
,
2300 in_data
, in_len
, out_data
, max_out_len
,
2304 NTSTATUS
smb_vfs_call_get_dos_attributes(struct vfs_handle_struct
*handle
,
2305 struct smb_filename
*smb_fname
,
2308 VFS_FIND(get_dos_attributes
);
2309 return handle
->fns
->get_dos_attributes_fn(handle
, smb_fname
, dosmode
);
2312 NTSTATUS
smb_vfs_call_fget_dos_attributes(struct vfs_handle_struct
*handle
,
2313 struct files_struct
*fsp
,
2316 VFS_FIND(fget_dos_attributes
);
2317 return handle
->fns
->fget_dos_attributes_fn(handle
, fsp
, dosmode
);
2320 NTSTATUS
smb_vfs_call_set_dos_attributes(struct vfs_handle_struct
*handle
,
2321 const struct smb_filename
*smb_fname
,
2324 VFS_FIND(set_dos_attributes
);
2325 return handle
->fns
->set_dos_attributes_fn(handle
, smb_fname
, dosmode
);
2328 NTSTATUS
smb_vfs_call_fset_dos_attributes(struct vfs_handle_struct
*handle
,
2329 struct files_struct
*fsp
,
2332 VFS_FIND(set_dos_attributes
);
2333 return handle
->fns
->fset_dos_attributes_fn(handle
, fsp
, dosmode
);
2336 struct tevent_req
*smb_vfs_call_offload_read_send(TALLOC_CTX
*mem_ctx
,
2337 struct tevent_context
*ev
,
2338 struct vfs_handle_struct
*handle
,
2339 struct files_struct
*fsp
,
2345 VFS_FIND(offload_read_send
);
2346 return handle
->fns
->offload_read_send_fn(mem_ctx
, ev
, handle
,
2348 ttl
, offset
, to_copy
);
2351 NTSTATUS
smb_vfs_call_offload_read_recv(struct tevent_req
*req
,
2352 struct vfs_handle_struct
*handle
,
2353 TALLOC_CTX
*mem_ctx
,
2354 DATA_BLOB
*token_blob
)
2356 VFS_FIND(offload_read_recv
);
2357 return handle
->fns
->offload_read_recv_fn(req
, handle
, mem_ctx
, token_blob
);
2360 struct tevent_req
*smb_vfs_call_offload_write_send(struct vfs_handle_struct
*handle
,
2361 TALLOC_CTX
*mem_ctx
,
2362 struct tevent_context
*ev
,
2365 off_t transfer_offset
,
2366 struct files_struct
*dest_fsp
,
2370 VFS_FIND(offload_write_send
);
2371 return handle
->fns
->offload_write_send_fn(handle
, mem_ctx
, ev
, fsctl
,
2372 token
, transfer_offset
,
2373 dest_fsp
, dest_off
, num
);
2376 NTSTATUS
smb_vfs_call_offload_write_recv(struct vfs_handle_struct
*handle
,
2377 struct tevent_req
*req
,
2380 VFS_FIND(offload_write_recv
);
2381 return handle
->fns
->offload_write_recv_fn(handle
, req
, copied
);
2384 struct smb_vfs_call_get_dos_attributes_state
{
2385 files_struct
*dir_fsp
;
2386 NTSTATUS (*recv_fn
)(struct tevent_req
*req
,
2387 struct vfs_aio_state
*aio_state
,
2389 struct vfs_aio_state aio_state
;
2390 uint32_t dos_attributes
;
2393 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req
*subreq
);
2395 struct tevent_req
*smb_vfs_call_get_dos_attributes_send(
2396 TALLOC_CTX
*mem_ctx
,
2397 struct tevent_context
*ev
,
2398 struct vfs_handle_struct
*handle
,
2399 files_struct
*dir_fsp
,
2400 struct smb_filename
*smb_fname
)
2402 struct tevent_req
*req
= NULL
;
2403 struct smb_vfs_call_get_dos_attributes_state
*state
= NULL
;
2404 struct tevent_req
*subreq
= NULL
;
2406 req
= tevent_req_create(mem_ctx
, &state
,
2407 struct smb_vfs_call_get_dos_attributes_state
);
2412 VFS_FIND(get_dos_attributes_send
);
2414 *state
= (struct smb_vfs_call_get_dos_attributes_state
) {
2416 .recv_fn
= handle
->fns
->get_dos_attributes_recv_fn
,
2419 subreq
= handle
->fns
->get_dos_attributes_send_fn(mem_ctx
,
2424 if (tevent_req_nomem(subreq
, req
)) {
2425 return tevent_req_post(req
, ev
);
2427 tevent_req_defer_callback(req
, ev
);
2429 tevent_req_set_callback(subreq
,
2430 smb_vfs_call_get_dos_attributes_done
,
2436 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req
*subreq
)
2438 struct tevent_req
*req
=
2439 tevent_req_callback_data(subreq
,
2441 struct smb_vfs_call_get_dos_attributes_state
*state
=
2442 tevent_req_data(req
,
2443 struct smb_vfs_call_get_dos_attributes_state
);
2448 * Make sure we run as the user again
2450 ok
= change_to_user_by_fsp(state
->dir_fsp
);
2453 status
= state
->recv_fn(subreq
,
2455 &state
->dos_attributes
);
2456 TALLOC_FREE(subreq
);
2457 if (tevent_req_nterror(req
, status
)) {
2461 tevent_req_done(req
);
2464 NTSTATUS
smb_vfs_call_get_dos_attributes_recv(
2465 struct tevent_req
*req
,
2466 struct vfs_aio_state
*aio_state
,
2467 uint32_t *dos_attributes
)
2469 struct smb_vfs_call_get_dos_attributes_state
*state
=
2470 tevent_req_data(req
,
2471 struct smb_vfs_call_get_dos_attributes_state
);
2474 if (tevent_req_is_nterror(req
, &status
)) {
2475 tevent_req_received(req
);
2479 *aio_state
= state
->aio_state
;
2480 *dos_attributes
= state
->dos_attributes
;
2481 tevent_req_received(req
);
2482 return NT_STATUS_OK
;
2485 NTSTATUS
smb_vfs_call_get_compression(vfs_handle_struct
*handle
,
2486 TALLOC_CTX
*mem_ctx
,
2487 struct files_struct
*fsp
,
2488 struct smb_filename
*smb_fname
,
2489 uint16_t *_compression_fmt
)
2491 VFS_FIND(get_compression
);
2492 return handle
->fns
->get_compression_fn(handle
, mem_ctx
, fsp
, smb_fname
,
2496 NTSTATUS
smb_vfs_call_set_compression(vfs_handle_struct
*handle
,
2497 TALLOC_CTX
*mem_ctx
,
2498 struct files_struct
*fsp
,
2499 uint16_t compression_fmt
)
2501 VFS_FIND(set_compression
);
2502 return handle
->fns
->set_compression_fn(handle
, mem_ctx
, fsp
,
2506 NTSTATUS
smb_vfs_call_snap_check_path(vfs_handle_struct
*handle
,
2507 TALLOC_CTX
*mem_ctx
,
2508 const char *service_path
,
2511 VFS_FIND(snap_check_path
);
2512 return handle
->fns
->snap_check_path_fn(handle
, mem_ctx
, service_path
,
2516 NTSTATUS
smb_vfs_call_snap_create(struct vfs_handle_struct
*handle
,
2517 TALLOC_CTX
*mem_ctx
,
2518 const char *base_volume
,
2524 VFS_FIND(snap_create
);
2525 return handle
->fns
->snap_create_fn(handle
, mem_ctx
, base_volume
, tstamp
,
2526 rw
, base_path
, snap_path
);
2529 NTSTATUS
smb_vfs_call_snap_delete(struct vfs_handle_struct
*handle
,
2530 TALLOC_CTX
*mem_ctx
,
2534 VFS_FIND(snap_delete
);
2535 return handle
->fns
->snap_delete_fn(handle
, mem_ctx
, base_path
,
2539 NTSTATUS
smb_vfs_call_fget_nt_acl(struct vfs_handle_struct
*handle
,
2540 struct files_struct
*fsp
,
2541 uint32_t security_info
,
2542 TALLOC_CTX
*mem_ctx
,
2543 struct security_descriptor
**ppdesc
)
2545 VFS_FIND(fget_nt_acl
);
2546 return handle
->fns
->fget_nt_acl_fn(handle
, fsp
, security_info
,
2550 NTSTATUS
smb_vfs_call_get_nt_acl(struct vfs_handle_struct
*handle
,
2551 const struct smb_filename
*smb_fname
,
2552 uint32_t security_info
,
2553 TALLOC_CTX
*mem_ctx
,
2554 struct security_descriptor
**ppdesc
)
2556 VFS_FIND(get_nt_acl
);
2557 return handle
->fns
->get_nt_acl_fn(handle
,
2564 NTSTATUS
smb_vfs_call_fset_nt_acl(struct vfs_handle_struct
*handle
,
2565 struct files_struct
*fsp
,
2566 uint32_t security_info_sent
,
2567 const struct security_descriptor
*psd
)
2569 VFS_FIND(fset_nt_acl
);
2570 return handle
->fns
->fset_nt_acl_fn(handle
, fsp
, security_info_sent
,
2574 NTSTATUS
smb_vfs_call_audit_file(struct vfs_handle_struct
*handle
,
2575 struct smb_filename
*file
,
2576 struct security_acl
*sacl
,
2577 uint32_t access_requested
,
2578 uint32_t access_denied
)
2580 VFS_FIND(audit_file
);
2581 return handle
->fns
->audit_file_fn(handle
,
2588 SMB_ACL_T
smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct
*handle
,
2589 const struct smb_filename
*smb_fname
,
2590 SMB_ACL_TYPE_T type
,
2591 TALLOC_CTX
*mem_ctx
)
2593 VFS_FIND(sys_acl_get_file
);
2594 return handle
->fns
->sys_acl_get_file_fn(handle
, smb_fname
, type
, mem_ctx
);
2597 SMB_ACL_T
smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct
*handle
,
2598 struct files_struct
*fsp
,
2599 TALLOC_CTX
*mem_ctx
)
2601 VFS_FIND(sys_acl_get_fd
);
2602 return handle
->fns
->sys_acl_get_fd_fn(handle
, fsp
, mem_ctx
);
2605 int smb_vfs_call_sys_acl_blob_get_file(struct vfs_handle_struct
*handle
,
2606 const struct smb_filename
*smb_fname
,
2607 TALLOC_CTX
*mem_ctx
,
2608 char **blob_description
,
2611 VFS_FIND(sys_acl_blob_get_file
);
2612 return handle
->fns
->sys_acl_blob_get_file_fn(handle
, smb_fname
,
2613 mem_ctx
, blob_description
, blob
);
2616 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct
*handle
,
2617 struct files_struct
*fsp
,
2618 TALLOC_CTX
*mem_ctx
,
2619 char **blob_description
,
2622 VFS_FIND(sys_acl_blob_get_fd
);
2623 return handle
->fns
->sys_acl_blob_get_fd_fn(handle
, fsp
, mem_ctx
, blob_description
, blob
);
2626 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct
*handle
,
2627 const struct smb_filename
*smb_fname
,
2628 SMB_ACL_TYPE_T acltype
,
2631 VFS_FIND(sys_acl_set_file
);
2632 return handle
->fns
->sys_acl_set_file_fn(handle
, smb_fname
,
2636 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct
*handle
,
2637 struct files_struct
*fsp
, SMB_ACL_T theacl
)
2639 VFS_FIND(sys_acl_set_fd
);
2640 return handle
->fns
->sys_acl_set_fd_fn(handle
, fsp
, theacl
);
2643 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct
*handle
,
2644 const struct smb_filename
*smb_fname
)
2646 VFS_FIND(sys_acl_delete_def_file
);
2647 return handle
->fns
->sys_acl_delete_def_file_fn(handle
, smb_fname
);
2650 ssize_t
smb_vfs_call_getxattr(struct vfs_handle_struct
*handle
,
2651 const struct smb_filename
*smb_fname
,
2657 return handle
->fns
->getxattr_fn(handle
, smb_fname
, name
, value
, size
);
2661 struct smb_vfs_call_getxattrat_state
{
2662 files_struct
*dir_fsp
;
2663 ssize_t (*recv_fn
)(struct tevent_req
*req
,
2664 struct vfs_aio_state
*aio_state
,
2665 TALLOC_CTX
*mem_ctx
,
2666 uint8_t **xattr_value
);
2668 uint8_t *xattr_value
;
2669 struct vfs_aio_state aio_state
;
2672 static void smb_vfs_call_getxattrat_done(struct tevent_req
*subreq
);
2674 struct tevent_req
*smb_vfs_call_getxattrat_send(
2675 TALLOC_CTX
*mem_ctx
,
2676 struct tevent_context
*ev
,
2677 struct vfs_handle_struct
*handle
,
2678 files_struct
*dir_fsp
,
2679 const struct smb_filename
*smb_fname
,
2680 const char *xattr_name
,
2683 struct tevent_req
*req
= NULL
;
2684 struct smb_vfs_call_getxattrat_state
*state
= NULL
;
2685 struct tevent_req
*subreq
= NULL
;
2687 req
= tevent_req_create(mem_ctx
, &state
,
2688 struct smb_vfs_call_getxattrat_state
);
2693 VFS_FIND(getxattrat_send
);
2695 *state
= (struct smb_vfs_call_getxattrat_state
) {
2697 .recv_fn
= handle
->fns
->getxattrat_recv_fn
,
2700 subreq
= handle
->fns
->getxattrat_send_fn(mem_ctx
,
2707 if (tevent_req_nomem(subreq
, req
)) {
2708 return tevent_req_post(req
, ev
);
2710 tevent_req_defer_callback(req
, ev
);
2712 tevent_req_set_callback(subreq
, smb_vfs_call_getxattrat_done
, req
);
2716 static void smb_vfs_call_getxattrat_done(struct tevent_req
*subreq
)
2718 struct tevent_req
*req
= tevent_req_callback_data(
2719 subreq
, struct tevent_req
);
2720 struct smb_vfs_call_getxattrat_state
*state
= tevent_req_data(
2721 req
, struct smb_vfs_call_getxattrat_state
);
2725 * Make sure we run as the user again
2727 ok
= change_to_user_by_fsp(state
->dir_fsp
);
2730 state
->retval
= state
->recv_fn(subreq
,
2733 &state
->xattr_value
);
2734 TALLOC_FREE(subreq
);
2735 if (state
->retval
== -1) {
2736 tevent_req_error(req
, state
->aio_state
.error
);
2740 tevent_req_done(req
);
2743 ssize_t
smb_vfs_call_getxattrat_recv(struct tevent_req
*req
,
2744 struct vfs_aio_state
*aio_state
,
2745 TALLOC_CTX
*mem_ctx
,
2746 uint8_t **xattr_value
)
2748 struct smb_vfs_call_getxattrat_state
*state
= tevent_req_data(
2749 req
, struct smb_vfs_call_getxattrat_state
);
2752 if (tevent_req_is_unix_error(req
, &aio_state
->error
)) {
2753 tevent_req_received(req
);
2757 *aio_state
= state
->aio_state
;
2758 xattr_size
= state
->retval
;
2759 if (xattr_value
!= NULL
) {
2760 *xattr_value
= talloc_move(mem_ctx
, &state
->xattr_value
);
2763 tevent_req_received(req
);
2767 ssize_t
smb_vfs_call_fgetxattr(struct vfs_handle_struct
*handle
,
2768 struct files_struct
*fsp
, const char *name
,
2769 void *value
, size_t size
)
2771 VFS_FIND(fgetxattr
);
2772 return handle
->fns
->fgetxattr_fn(handle
, fsp
, name
, value
, size
);
2775 ssize_t
smb_vfs_call_listxattr(struct vfs_handle_struct
*handle
,
2776 const struct smb_filename
*smb_fname
,
2780 VFS_FIND(listxattr
);
2781 return handle
->fns
->listxattr_fn(handle
, smb_fname
, list
, size
);
2784 ssize_t
smb_vfs_call_flistxattr(struct vfs_handle_struct
*handle
,
2785 struct files_struct
*fsp
, char *list
,
2788 VFS_FIND(flistxattr
);
2789 return handle
->fns
->flistxattr_fn(handle
, fsp
, list
, size
);
2792 int smb_vfs_call_removexattr(struct vfs_handle_struct
*handle
,
2793 const struct smb_filename
*smb_fname
,
2796 VFS_FIND(removexattr
);
2797 return handle
->fns
->removexattr_fn(handle
, smb_fname
, name
);
2800 int smb_vfs_call_fremovexattr(struct vfs_handle_struct
*handle
,
2801 struct files_struct
*fsp
, const char *name
)
2803 VFS_FIND(fremovexattr
);
2804 return handle
->fns
->fremovexattr_fn(handle
, fsp
, name
);
2807 int smb_vfs_call_setxattr(struct vfs_handle_struct
*handle
,
2808 const struct smb_filename
*smb_fname
,
2815 return handle
->fns
->setxattr_fn(handle
, smb_fname
,
2816 name
, value
, size
, flags
);
2819 int smb_vfs_call_fsetxattr(struct vfs_handle_struct
*handle
,
2820 struct files_struct
*fsp
, const char *name
,
2821 const void *value
, size_t size
, int flags
)
2823 VFS_FIND(fsetxattr
);
2824 return handle
->fns
->fsetxattr_fn(handle
, fsp
, name
, value
, size
, flags
);
2827 bool smb_vfs_call_aio_force(struct vfs_handle_struct
*handle
,
2828 struct files_struct
*fsp
)
2830 VFS_FIND(aio_force
);
2831 return handle
->fns
->aio_force_fn(handle
, fsp
);
2834 NTSTATUS
smb_vfs_call_durable_cookie(struct vfs_handle_struct
*handle
,
2835 struct files_struct
*fsp
,
2836 TALLOC_CTX
*mem_ctx
,
2839 VFS_FIND(durable_cookie
);
2840 return handle
->fns
->durable_cookie_fn(handle
, fsp
, mem_ctx
, cookie
);
2843 NTSTATUS
smb_vfs_call_durable_disconnect(struct vfs_handle_struct
*handle
,
2844 struct files_struct
*fsp
,
2845 const DATA_BLOB old_cookie
,
2846 TALLOC_CTX
*mem_ctx
,
2847 DATA_BLOB
*new_cookie
)
2849 VFS_FIND(durable_disconnect
);
2850 return handle
->fns
->durable_disconnect_fn(handle
, fsp
, old_cookie
,
2851 mem_ctx
, new_cookie
);
2854 NTSTATUS
smb_vfs_call_durable_reconnect(struct vfs_handle_struct
*handle
,
2855 struct smb_request
*smb1req
,
2856 struct smbXsrv_open
*op
,
2857 const DATA_BLOB old_cookie
,
2858 TALLOC_CTX
*mem_ctx
,
2859 struct files_struct
**fsp
,
2860 DATA_BLOB
*new_cookie
)
2862 VFS_FIND(durable_reconnect
);
2863 return handle
->fns
->durable_reconnect_fn(handle
, smb1req
, op
,
2864 old_cookie
, mem_ctx
, fsp
,
2868 NTSTATUS
smb_vfs_call_readdir_attr(struct vfs_handle_struct
*handle
,
2869 const struct smb_filename
*fname
,
2870 TALLOC_CTX
*mem_ctx
,
2871 struct readdir_attr_data
**attr_data
)
2873 VFS_FIND(readdir_attr
);
2874 return handle
->fns
->readdir_attr_fn(handle
, fname
, mem_ctx
, attr_data
);