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 "smbd/globals.h"
31 #define DBGC_CLASS DBGC_VFS
35 struct vfs_init_function_entry
{
37 struct vfs_init_function_entry
*prev
, *next
;
38 const struct vfs_fn_pointers
*fns
;
41 /****************************************************************************
42 maintain the list of available backends
43 ****************************************************************************/
45 static struct vfs_init_function_entry
*vfs_find_backend_entry(const char *name
)
47 struct vfs_init_function_entry
*entry
= backends
;
49 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name
));
52 if (strcmp(entry
->name
, name
)==0) return entry
;
59 NTSTATUS
smb_register_vfs(int version
, const char *name
,
60 const struct vfs_fn_pointers
*fns
)
62 struct vfs_init_function_entry
*entry
= backends
;
64 if ((version
!= SMB_VFS_INTERFACE_VERSION
)) {
65 DEBUG(0, ("Failed to register vfs module.\n"
66 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
67 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
68 "Please recompile against the current Samba Version!\n",
69 version
, SMB_VFS_INTERFACE_VERSION
));
70 return NT_STATUS_OBJECT_TYPE_MISMATCH
;
73 if (!name
|| !name
[0]) {
74 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
75 return NT_STATUS_INVALID_PARAMETER
;
78 if (vfs_find_backend_entry(name
)) {
79 DEBUG(0,("VFS module %s already loaded!\n", name
));
80 return NT_STATUS_OBJECT_NAME_COLLISION
;
83 entry
= SMB_XMALLOC_P(struct vfs_init_function_entry
);
84 entry
->name
= smb_xstrdup(name
);
87 DLIST_ADD(backends
, entry
);
88 DEBUG(5, ("Successfully added vfs backend '%s'\n", name
));
92 /****************************************************************************
93 initialise default vfs hooks
94 ****************************************************************************/
96 static void vfs_init_default(connection_struct
*conn
)
98 DEBUG(3, ("Initialising default vfs hooks\n"));
99 vfs_init_custom(conn
, DEFAULT_VFS_MODULE_NAME
);
102 /****************************************************************************
103 initialise custom vfs hooks
104 ****************************************************************************/
106 bool vfs_init_custom(connection_struct
*conn
, const char *vfs_object
)
108 char *module_path
= NULL
;
109 char *module_name
= NULL
;
110 char *module_param
= NULL
, *p
;
111 vfs_handle_struct
*handle
;
112 const struct vfs_init_function_entry
*entry
;
114 if (!conn
||!vfs_object
||!vfs_object
[0]) {
115 DEBUG(0, ("vfs_init_custom() called with NULL pointer or "
116 "empty vfs_object!\n"));
124 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object
));
126 module_path
= smb_xstrdup(vfs_object
);
128 p
= strchr_m(module_path
, ':');
133 trim_char(module_param
, ' ', ' ');
136 trim_char(module_path
, ' ', ' ');
138 module_name
= smb_xstrdup(module_path
);
140 if ((module_name
[0] == '/') &&
141 (strcmp(module_path
, DEFAULT_VFS_MODULE_NAME
) != 0)) {
144 * Extract the module name from the path. Just use the base
145 * name of the last path component.
148 SAFE_FREE(module_name
);
149 module_name
= smb_xstrdup(strrchr_m(module_path
, '/')+1);
151 p
= strchr_m(module_name
, '.');
158 /* First, try to load the module with the new module system */
159 entry
= vfs_find_backend_entry(module_name
);
163 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
166 status
= smb_probe_module("vfs", module_path
);
167 if (!NT_STATUS_IS_OK(status
)) {
168 DEBUG(0, ("error probing vfs module '%s': %s\n",
169 module_path
, nt_errstr(status
)));
173 entry
= vfs_find_backend_entry(module_name
);
175 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object
));
180 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object
));
182 handle
= TALLOC_ZERO_P(conn
, vfs_handle_struct
);
184 DEBUG(0,("TALLOC_ZERO() failed!\n"));
188 handle
->fns
= entry
->fns
;
190 handle
->param
= talloc_strdup(conn
, module_param
);
192 DLIST_ADD(conn
->vfs_handles
, handle
);
194 SAFE_FREE(module_path
);
195 SAFE_FREE(module_name
);
199 SAFE_FREE(module_path
);
200 SAFE_FREE(module_name
);
204 /*****************************************************************
205 Allow VFS modules to extend files_struct with VFS-specific state.
206 This will be ok for small numbers of extensions, but might need to
207 be refactored if it becomes more widely used.
208 ******************************************************************/
210 #define EXT_DATA_AREA(e) ((uint8 *)(e) + sizeof(struct vfs_fsp_data))
212 void *vfs_add_fsp_extension_notype(vfs_handle_struct
*handle
,
213 files_struct
*fsp
, size_t ext_size
,
214 void (*destroy_fn
)(void *p_data
))
216 struct vfs_fsp_data
*ext
;
219 /* Prevent VFS modules adding multiple extensions. */
220 if ((ext_data
= vfs_fetch_fsp_extension(handle
, fsp
))) {
224 ext
= (struct vfs_fsp_data
*)TALLOC_ZERO(
225 handle
->conn
, sizeof(struct vfs_fsp_data
) + ext_size
);
231 ext
->next
= fsp
->vfs_extension
;
232 ext
->destroy
= destroy_fn
;
233 fsp
->vfs_extension
= ext
;
234 return EXT_DATA_AREA(ext
);
237 void vfs_remove_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
239 struct vfs_fsp_data
*curr
;
240 struct vfs_fsp_data
*prev
;
242 for (curr
= fsp
->vfs_extension
, prev
= NULL
;
244 prev
= curr
, curr
= curr
->next
) {
245 if (curr
->owner
== handle
) {
247 prev
->next
= curr
->next
;
249 fsp
->vfs_extension
= curr
->next
;
252 curr
->destroy(EXT_DATA_AREA(curr
));
260 void *vfs_memctx_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
262 struct vfs_fsp_data
*head
;
264 for (head
= fsp
->vfs_extension
; head
; head
= head
->next
) {
265 if (head
->owner
== handle
) {
273 void *vfs_fetch_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
275 struct vfs_fsp_data
*head
;
277 head
= (struct vfs_fsp_data
*)vfs_memctx_fsp_extension(handle
, fsp
);
279 return EXT_DATA_AREA(head
);
287 /*****************************************************************
289 ******************************************************************/
291 bool smbd_vfs_init(connection_struct
*conn
)
293 const char **vfs_objects
;
297 /* Normal share - initialise with disk access functions */
298 vfs_init_default(conn
);
299 vfs_objects
= lp_vfs_objects(SNUM(conn
));
301 /* Override VFS functions if 'vfs object' was not specified*/
302 if (!vfs_objects
|| !vfs_objects
[0])
305 for (i
=0; vfs_objects
[i
] ;) {
309 for (j
=i
-1; j
>= 0; j
--) {
310 if (!vfs_init_custom(conn
, vfs_objects
[j
])) {
311 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects
[j
]));
318 /*******************************************************************
319 Check if a file exists in the vfs.
320 ********************************************************************/
322 NTSTATUS
vfs_file_exist(connection_struct
*conn
, struct smb_filename
*smb_fname
)
324 /* Only return OK if stat was successful and S_ISREG */
325 if ((SMB_VFS_STAT(conn
, smb_fname
) != -1) &&
326 S_ISREG(smb_fname
->st
.st_ex_mode
)) {
330 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
333 /****************************************************************************
334 Read data from fsp on the vfs. (note: EINTR re-read differs from vfs_write_data)
335 ****************************************************************************/
337 ssize_t
vfs_read_data(files_struct
*fsp
, char *buf
, size_t byte_count
)
341 while (total
< byte_count
)
343 ssize_t ret
= SMB_VFS_READ(fsp
, buf
+ total
,
346 if (ret
== 0) return total
;
355 return (ssize_t
)total
;
358 ssize_t
vfs_pread_data(files_struct
*fsp
, char *buf
,
359 size_t byte_count
, SMB_OFF_T offset
)
363 while (total
< byte_count
)
365 ssize_t ret
= SMB_VFS_PREAD(fsp
, buf
+ total
,
366 byte_count
- total
, offset
+ total
);
368 if (ret
== 0) return total
;
377 return (ssize_t
)total
;
380 /****************************************************************************
381 Write data to a fd on the vfs.
382 ****************************************************************************/
384 ssize_t
vfs_write_data(struct smb_request
*req
,
392 if (req
&& req
->unread_bytes
) {
393 SMB_ASSERT(req
->unread_bytes
== N
);
394 /* VFS_RECVFILE must drain the socket
395 * before returning. */
396 req
->unread_bytes
= 0;
397 return SMB_VFS_RECVFILE(req
->sconn
->sock
,
404 ret
= SMB_VFS_WRITE(fsp
, buffer
+ total
, N
- total
);
413 return (ssize_t
)total
;
416 ssize_t
vfs_pwrite_data(struct smb_request
*req
,
425 if (req
&& req
->unread_bytes
) {
426 SMB_ASSERT(req
->unread_bytes
== N
);
427 /* VFS_RECVFILE must drain the socket
428 * before returning. */
429 req
->unread_bytes
= 0;
430 return SMB_VFS_RECVFILE(req
->sconn
->sock
,
437 ret
= SMB_VFS_PWRITE(fsp
, buffer
+ total
, N
- total
,
447 return (ssize_t
)total
;
449 /****************************************************************************
450 An allocate file space call using the vfs interface.
451 Allocates space for a file from a filedescriptor.
452 Returns 0 on success, -1 on failure.
453 ****************************************************************************/
455 int vfs_allocate_file_space(files_struct
*fsp
, uint64_t len
)
459 connection_struct
*conn
= fsp
->conn
;
460 uint64_t space_avail
;
461 uint64_t bsize
,dfree
,dsize
;
464 * Actually try and commit the space on disk....
467 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
468 fsp_str_dbg(fsp
), (double)len
));
470 if (((SMB_OFF_T
)len
) < 0) {
471 DEBUG(0,("vfs_allocate_file_space: %s negative len "
472 "requested.\n", fsp_str_dbg(fsp
)));
477 ret
= SMB_VFS_FSTAT(fsp
, &st
);
481 if (len
== (uint64_t)st
.st_ex_size
)
484 if (len
< (uint64_t)st
.st_ex_size
) {
485 /* Shrink - use ftruncate. */
487 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current "
488 "size %.0f\n", fsp_str_dbg(fsp
),
489 (double)st
.st_ex_size
));
491 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
493 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
494 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, (SMB_OFF_T
)len
)) != -1) {
495 set_filelen_write_cache(fsp
, len
);
498 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
503 /* Grow - we need to test if we have enough space. */
505 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
506 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
508 if (!lp_strict_allocate(SNUM(fsp
->conn
)))
511 len
-= st
.st_ex_size
;
512 len
/= 1024; /* Len is now number of 1k blocks needed. */
513 space_avail
= get_dfree_info(conn
, fsp
->fsp_name
->base_name
, false,
514 &bsize
, &dfree
, &dsize
);
515 if (space_avail
== (uint64_t)-1) {
519 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
520 "needed blocks = %.0f, space avail = %.0f\n",
521 fsp_str_dbg(fsp
), (double)st
.st_ex_size
, (double)len
,
522 (double)space_avail
));
524 if (len
> space_avail
) {
532 /****************************************************************************
533 A vfs set_filelen call.
534 set the length of a file from a filedescriptor.
535 Returns 0 on success, -1 on failure.
536 ****************************************************************************/
538 int vfs_set_filelen(files_struct
*fsp
, SMB_OFF_T len
)
542 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
544 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
545 fsp_str_dbg(fsp
), (double)len
));
546 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
547 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, len
)) != -1) {
548 set_filelen_write_cache(fsp
, len
);
549 notify_fname(fsp
->conn
, NOTIFY_ACTION_MODIFIED
,
550 FILE_NOTIFY_CHANGE_SIZE
551 | FILE_NOTIFY_CHANGE_ATTRIBUTES
,
552 fsp
->fsp_name
->base_name
);
555 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
560 /****************************************************************************
561 A vfs fill sparse call.
562 Writes zeros from the end of file to len, if len is greater than EOF.
563 Used only by strict_sync.
564 Returns 0 on success, -1 on failure.
565 ****************************************************************************/
567 #define SPARSE_BUF_WRITE_SIZE (32*1024)
569 int vfs_fill_sparse(files_struct
*fsp
, SMB_OFF_T len
)
578 ret
= SMB_VFS_FSTAT(fsp
, &st
);
583 if (len
<= st
.st_ex_size
) {
587 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
588 "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp
),
589 (double)st
.st_ex_size
, (double)len
,
590 (double)(len
- st
.st_ex_size
)));
592 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
594 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
597 sparse_buf
= SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE
);
605 offset
= st
.st_ex_size
;
606 num_to_write
= len
- st
.st_ex_size
;
609 while (total
< num_to_write
) {
610 size_t curr_write_size
= MIN(SPARSE_BUF_WRITE_SIZE
, (num_to_write
- total
));
612 pwrite_ret
= SMB_VFS_PWRITE(fsp
, sparse_buf
, curr_write_size
, offset
+ total
);
613 if (pwrite_ret
== -1) {
614 DEBUG(10,("vfs_fill_sparse: SMB_VFS_PWRITE for file "
615 "%s failed with error %s\n",
616 fsp_str_dbg(fsp
), strerror(errno
)));
620 if (pwrite_ret
== 0) {
628 set_filelen_write_cache(fsp
, len
);
632 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
636 /****************************************************************************
637 Transfer some data (n bytes) between two file_struct's.
638 ****************************************************************************/
640 static ssize_t
vfs_read_fn(void *file
, void *buf
, size_t len
)
642 struct files_struct
*fsp
= (struct files_struct
*)file
;
644 return SMB_VFS_READ(fsp
, buf
, len
);
647 static ssize_t
vfs_write_fn(void *file
, const void *buf
, size_t len
)
649 struct files_struct
*fsp
= (struct files_struct
*)file
;
651 return SMB_VFS_WRITE(fsp
, buf
, len
);
654 SMB_OFF_T
vfs_transfer_file(files_struct
*in
, files_struct
*out
, SMB_OFF_T n
)
656 return transfer_file_internal((void *)in
, (void *)out
, n
,
657 vfs_read_fn
, vfs_write_fn
);
660 /*******************************************************************
661 A vfs_readdir wrapper which just returns the file name.
662 ********************************************************************/
664 const char *vfs_readdirname(connection_struct
*conn
, void *p
,
665 SMB_STRUCT_STAT
*sbuf
, char **talloced
)
667 SMB_STRUCT_DIRENT
*ptr
= NULL
;
675 ptr
= SMB_VFS_READDIR(conn
, (DIR *)p
, sbuf
);
687 #ifdef HAVE_BROKEN_READDIR_NAME
688 /* using /usr/ucb/cc is BAD */
692 status
= SMB_VFS_TRANSLATE_NAME(conn
, dname
, vfs_translate_to_windows
,
693 talloc_tos(), &translated
);
694 if (NT_STATUS_EQUAL(status
, NT_STATUS_NONE_MAPPED
)) {
698 *talloced
= translated
;
699 if (!NT_STATUS_IS_OK(status
)) {
705 /*******************************************************************
706 A wrapper for vfs_chdir().
707 ********************************************************************/
709 int vfs_ChDir(connection_struct
*conn
, const char *path
)
714 LastDir
= SMB_STRDUP("");
717 if (strcsequal(path
,"."))
720 if (*path
== '/' && strcsequal(LastDir
,path
))
723 DEBUG(4,("vfs_ChDir to %s\n",path
));
725 res
= SMB_VFS_CHDIR(conn
,path
);
728 LastDir
= SMB_STRDUP(path
);
733 /*******************************************************************
734 Return the absolute current directory path - given a UNIX pathname.
735 Note that this path is returned in DOS format, not UNIX
736 format. Note this can be called with conn == NULL.
737 ********************************************************************/
739 char *vfs_GetWd(TALLOC_CTX
*ctx
, connection_struct
*conn
)
743 DATA_BLOB cache_value
;
745 struct smb_filename
*smb_fname_dot
= NULL
;
746 struct smb_filename
*smb_fname_full
= NULL
;
751 if (!lp_getwd_cache()) {
755 status
= create_synthetic_smb_fname(ctx
, ".", NULL
, NULL
,
757 if (!NT_STATUS_IS_OK(status
)) {
758 errno
= map_errno_from_nt_status(status
);
762 if (SMB_VFS_STAT(conn
, smb_fname_dot
) == -1) {
764 * Known to fail for root: the directory may be NFS-mounted
765 * and exported with root_squash (so has no root access).
767 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
768 "(NFS problem ?)\n", strerror(errno
) ));
772 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
774 if (!memcache_lookup(smbd_memcache(), GETWD_CACHE
,
775 data_blob_const(&key
, sizeof(key
)),
780 SMB_ASSERT((cache_value
.length
> 0)
781 && (cache_value
.data
[cache_value
.length
-1] == '\0'));
783 status
= create_synthetic_smb_fname(ctx
, (char *)cache_value
.data
,
784 NULL
, NULL
, &smb_fname_full
);
785 if (!NT_STATUS_IS_OK(status
)) {
786 errno
= map_errno_from_nt_status(status
);
790 if ((SMB_VFS_STAT(conn
, smb_fname_full
) == 0) &&
791 (smb_fname_dot
->st
.st_ex_dev
== smb_fname_full
->st
.st_ex_dev
) &&
792 (smb_fname_dot
->st
.st_ex_ino
== smb_fname_full
->st
.st_ex_ino
) &&
793 (S_ISDIR(smb_fname_dot
->st
.st_ex_mode
))) {
797 result
= talloc_strdup(ctx
, smb_fname_full
->base_name
);
798 if (result
== NULL
) {
807 * We don't have the information to hand so rely on traditional
808 * methods. The very slow getcwd, which spawns a process on some
809 * systems, or the not quite so bad getwd.
812 if (!SMB_VFS_GETWD(conn
,s
)) {
813 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
818 if (lp_getwd_cache() && VALID_STAT(smb_fname_dot
->st
)) {
819 key
= vfs_file_id_from_sbuf(conn
, &smb_fname_dot
->st
);
821 memcache_add(smbd_memcache(), GETWD_CACHE
,
822 data_blob_const(&key
, sizeof(key
)),
823 data_blob_const(s
, strlen(s
)+1));
826 result
= talloc_strdup(ctx
, s
);
827 if (result
== NULL
) {
832 TALLOC_FREE(smb_fname_dot
);
833 TALLOC_FREE(smb_fname_full
);
837 /*******************************************************************
838 Reduce a file name, removing .. elements and checking that
839 it is below dir in the heirachy. This uses realpath.
840 ********************************************************************/
842 NTSTATUS
check_reduced_name(connection_struct
*conn
, const char *fname
)
844 char *resolved_name
= NULL
;
847 DEBUG(3,("check_reduced_name [%s] [%s]\n", fname
, conn
->connectpath
));
849 resolved_name
= SMB_VFS_REALPATH(conn
,fname
);
851 if (!resolved_name
) {
854 DEBUG(3,("check_reduced_name: Component not a "
855 "directory in getting realpath for "
857 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
860 TALLOC_CTX
*ctx
= talloc_tos();
861 char *tmp_fname
= NULL
;
862 char *last_component
= NULL
;
863 /* Last component didn't exist. Remove it and try and canonicalise the directory. */
865 tmp_fname
= talloc_strdup(ctx
, fname
);
867 return NT_STATUS_NO_MEMORY
;
869 p
= strrchr_m(tmp_fname
, '/');
874 last_component
= tmp_fname
;
875 tmp_fname
= talloc_strdup(ctx
,
878 return NT_STATUS_NO_MEMORY
;
882 resolved_name
= SMB_VFS_REALPATH(conn
,tmp_fname
);
883 if (!resolved_name
) {
884 NTSTATUS status
= map_nt_error_from_unix(errno
);
886 if (errno
== ENOENT
|| errno
== ENOTDIR
) {
887 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
890 DEBUG(3,("check_reduce_named: "
891 "couldn't get realpath for "
897 tmp_fname
= talloc_asprintf(ctx
,
902 return NT_STATUS_NO_MEMORY
;
904 SAFE_FREE(resolved_name
);
905 resolved_name
= SMB_STRDUP(tmp_fname
);
906 if (!resolved_name
) {
907 DEBUG(0, ("check_reduced_name: malloc "
908 "fail for %s\n", tmp_fname
));
909 return NT_STATUS_NO_MEMORY
;
914 DEBUG(3,("check_reduced_name: couldn't get "
915 "realpath for %s\n", fname
));
916 return map_nt_error_from_unix(errno
);
920 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname
,
923 if (*resolved_name
!= '/') {
924 DEBUG(0,("check_reduced_name: realpath doesn't return "
925 "absolute paths !\n"));
926 SAFE_FREE(resolved_name
);
927 return NT_STATUS_OBJECT_NAME_INVALID
;
930 /* Check for widelinks allowed. */
931 if (!lp_widelinks(SNUM(conn
))) {
932 const char *conn_rootdir
;
934 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, fname
);
935 if (conn_rootdir
== NULL
) {
936 DEBUG(2, ("check_reduced_name: Could not get "
938 SAFE_FREE(resolved_name
);
939 return NT_STATUS_ACCESS_DENIED
;
942 if (strncmp(conn_rootdir
, resolved_name
,
943 strlen(conn_rootdir
)) != 0) {
944 DEBUG(2, ("check_reduced_name: Bad access "
945 "attempt: %s is a symlink outside the "
946 "share path\n", fname
));
947 SAFE_FREE(resolved_name
);
948 return NT_STATUS_ACCESS_DENIED
;
952 /* Check if we are allowing users to follow symlinks */
953 /* Patch from David Clerc <David.Clerc@cui.unige.ch>
954 University of Geneva */
957 if (!lp_symlinks(SNUM(conn
))) {
958 struct smb_filename
*smb_fname
= NULL
;
961 status
= create_synthetic_smb_fname(talloc_tos(), fname
, NULL
,
963 if (!NT_STATUS_IS_OK(status
)) {
964 SAFE_FREE(resolved_name
);
968 if ( (SMB_VFS_LSTAT(conn
, smb_fname
) != -1) &&
969 (S_ISLNK(smb_fname
->st
.st_ex_mode
)) ) {
970 SAFE_FREE(resolved_name
);
971 DEBUG(3,("check_reduced_name: denied: file path name "
972 "%s is a symlink\n",resolved_name
));
973 TALLOC_FREE(smb_fname
);
974 return NT_STATUS_ACCESS_DENIED
;
976 TALLOC_FREE(smb_fname
);
980 DEBUG(3,("check_reduced_name: %s reduced to %s\n", fname
,
982 SAFE_FREE(resolved_name
);
987 * XXX: This is temporary and there should be no callers of this once
988 * smb_filename is plumbed through all path based operations.
990 int vfs_stat_smb_fname(struct connection_struct
*conn
, const char *fname
,
991 SMB_STRUCT_STAT
*psbuf
)
993 struct smb_filename
*smb_fname
= NULL
;
997 status
= create_synthetic_smb_fname_split(talloc_tos(), fname
, NULL
,
999 if (!NT_STATUS_IS_OK(status
)) {
1000 errno
= map_errno_from_nt_status(status
);
1004 if (lp_posix_pathnames()) {
1005 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
1007 ret
= SMB_VFS_STAT(conn
, smb_fname
);
1011 *psbuf
= smb_fname
->st
;
1014 TALLOC_FREE(smb_fname
);
1019 * XXX: This is temporary and there should be no callers of this once
1020 * smb_filename is plumbed through all path based operations.
1022 int vfs_lstat_smb_fname(struct connection_struct
*conn
, const char *fname
,
1023 SMB_STRUCT_STAT
*psbuf
)
1025 struct smb_filename
*smb_fname
= NULL
;
1029 status
= create_synthetic_smb_fname_split(talloc_tos(), fname
, NULL
,
1031 if (!NT_STATUS_IS_OK(status
)) {
1032 errno
= map_errno_from_nt_status(status
);
1036 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
1038 *psbuf
= smb_fname
->st
;
1041 TALLOC_FREE(smb_fname
);
1046 * Ensure LSTAT is called for POSIX paths.
1049 NTSTATUS
vfs_stat_fsp(files_struct
*fsp
)
1053 if(fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
1054 if (fsp
->posix_open
) {
1055 ret
= SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1057 ret
= SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1060 return map_nt_error_from_unix(errno
);
1063 if(SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) != 0) {
1064 return map_nt_error_from_unix(errno
);
1067 return NT_STATUS_OK
;
1071 generate a file_id from a stat structure
1073 struct file_id
vfs_file_id_from_sbuf(connection_struct
*conn
, const SMB_STRUCT_STAT
*sbuf
)
1075 return SMB_VFS_FILE_ID_CREATE(conn
, sbuf
);
1078 int smb_vfs_call_connect(struct vfs_handle_struct
*handle
,
1079 const char *service
, const char *user
)
1081 VFS_FIND(connect_fn
);
1082 return handle
->fns
->connect_fn(handle
, service
, user
);
1085 void smb_vfs_call_disconnect(struct vfs_handle_struct
*handle
)
1087 VFS_FIND(disconnect
);
1088 handle
->fns
->disconnect(handle
);
1091 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct
*handle
,
1092 const char *path
, bool small_query
,
1093 uint64_t *bsize
, uint64_t *dfree
,
1096 VFS_FIND(disk_free
);
1097 return handle
->fns
->disk_free(handle
, path
, small_query
, bsize
, dfree
,
1101 int smb_vfs_call_get_quota(struct vfs_handle_struct
*handle
,
1102 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1105 VFS_FIND(get_quota
);
1106 return handle
->fns
->get_quota(handle
, qtype
, id
, qt
);
1109 int smb_vfs_call_set_quota(struct vfs_handle_struct
*handle
,
1110 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1113 VFS_FIND(set_quota
);
1114 return handle
->fns
->set_quota(handle
, qtype
, id
, qt
);
1117 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
1118 struct files_struct
*fsp
,
1119 SHADOW_COPY_DATA
*shadow_copy_data
,
1122 VFS_FIND(get_shadow_copy_data
);
1123 return handle
->fns
->get_shadow_copy_data(handle
, fsp
, shadow_copy_data
,
1126 int smb_vfs_call_statvfs(struct vfs_handle_struct
*handle
, const char *path
,
1127 struct vfs_statvfs_struct
*statbuf
)
1130 return handle
->fns
->statvfs(handle
, path
, statbuf
);
1133 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct
*handle
,
1134 enum timestamp_set_resolution
*p_ts_res
)
1136 VFS_FIND(fs_capabilities
);
1137 return handle
->fns
->fs_capabilities(handle
, p_ts_res
);
1140 SMB_STRUCT_DIR
*smb_vfs_call_opendir(struct vfs_handle_struct
*handle
,
1141 const char *fname
, const char *mask
,
1145 return handle
->fns
->opendir(handle
, fname
, mask
, attributes
);
1148 SMB_STRUCT_DIRENT
*smb_vfs_call_readdir(struct vfs_handle_struct
*handle
,
1149 SMB_STRUCT_DIR
*dirp
,
1150 SMB_STRUCT_STAT
*sbuf
)
1153 return handle
->fns
->readdir(handle
, dirp
, sbuf
);
1156 void smb_vfs_call_seekdir(struct vfs_handle_struct
*handle
,
1157 SMB_STRUCT_DIR
*dirp
, long offset
)
1160 handle
->fns
->seekdir(handle
, dirp
, offset
);
1163 long smb_vfs_call_telldir(struct vfs_handle_struct
*handle
,
1164 SMB_STRUCT_DIR
*dirp
)
1167 return handle
->fns
->telldir(handle
, dirp
);
1170 void smb_vfs_call_rewind_dir(struct vfs_handle_struct
*handle
,
1171 SMB_STRUCT_DIR
*dirp
)
1173 VFS_FIND(rewind_dir
);
1174 handle
->fns
->rewind_dir(handle
, dirp
);
1177 int smb_vfs_call_mkdir(struct vfs_handle_struct
*handle
, const char *path
,
1181 return handle
->fns
->mkdir(handle
, path
, mode
);
1184 int smb_vfs_call_rmdir(struct vfs_handle_struct
*handle
, const char *path
)
1187 return handle
->fns
->rmdir(handle
, path
);
1190 int smb_vfs_call_closedir(struct vfs_handle_struct
*handle
,
1191 SMB_STRUCT_DIR
*dir
)
1194 return handle
->fns
->closedir(handle
, dir
);
1197 void smb_vfs_call_init_search_op(struct vfs_handle_struct
*handle
,
1198 SMB_STRUCT_DIR
*dirp
)
1200 VFS_FIND(init_search_op
);
1201 handle
->fns
->init_search_op(handle
, dirp
);
1204 int smb_vfs_call_open(struct vfs_handle_struct
*handle
,
1205 struct smb_filename
*smb_fname
, struct files_struct
*fsp
,
1206 int flags
, mode_t mode
)
1209 return handle
->fns
->open(handle
, smb_fname
, fsp
, flags
, mode
);
1212 NTSTATUS
smb_vfs_call_create_file(struct vfs_handle_struct
*handle
,
1213 struct smb_request
*req
,
1214 uint16_t root_dir_fid
,
1215 struct smb_filename
*smb_fname
,
1216 uint32_t access_mask
,
1217 uint32_t share_access
,
1218 uint32_t create_disposition
,
1219 uint32_t create_options
,
1220 uint32_t file_attributes
,
1221 uint32_t oplock_request
,
1222 uint64_t allocation_size
,
1223 uint32_t private_flags
,
1224 struct security_descriptor
*sd
,
1225 struct ea_list
*ea_list
,
1226 files_struct
**result
,
1229 VFS_FIND(create_file
);
1230 return handle
->fns
->create_file(
1231 handle
, req
, root_dir_fid
, smb_fname
, access_mask
,
1232 share_access
, create_disposition
, create_options
,
1233 file_attributes
, oplock_request
, allocation_size
,
1234 private_flags
, sd
, ea_list
,
1238 int smb_vfs_call_close_fn(struct vfs_handle_struct
*handle
,
1239 struct files_struct
*fsp
)
1242 return handle
->fns
->close_fn(handle
, fsp
);
1245 ssize_t
smb_vfs_call_vfs_read(struct vfs_handle_struct
*handle
,
1246 struct files_struct
*fsp
, void *data
, size_t n
)
1249 return handle
->fns
->vfs_read(handle
, fsp
, data
, n
);
1252 ssize_t
smb_vfs_call_pread(struct vfs_handle_struct
*handle
,
1253 struct files_struct
*fsp
, void *data
, size_t n
,
1257 return handle
->fns
->pread(handle
, fsp
, data
, n
, offset
);
1260 ssize_t
smb_vfs_call_write(struct vfs_handle_struct
*handle
,
1261 struct files_struct
*fsp
, const void *data
,
1265 return handle
->fns
->write(handle
, fsp
, data
, n
);
1268 ssize_t
smb_vfs_call_pwrite(struct vfs_handle_struct
*handle
,
1269 struct files_struct
*fsp
, const void *data
,
1270 size_t n
, SMB_OFF_T offset
)
1273 return handle
->fns
->pwrite(handle
, fsp
, data
, n
, offset
);
1276 SMB_OFF_T
smb_vfs_call_lseek(struct vfs_handle_struct
*handle
,
1277 struct files_struct
*fsp
, SMB_OFF_T offset
,
1281 return handle
->fns
->lseek(handle
, fsp
, offset
, whence
);
1284 ssize_t
smb_vfs_call_sendfile(struct vfs_handle_struct
*handle
, int tofd
,
1285 files_struct
*fromfsp
, const DATA_BLOB
*header
,
1286 SMB_OFF_T offset
, size_t count
)
1289 return handle
->fns
->sendfile(handle
, tofd
, fromfsp
, header
, offset
,
1293 ssize_t
smb_vfs_call_recvfile(struct vfs_handle_struct
*handle
, int fromfd
,
1294 files_struct
*tofsp
, SMB_OFF_T offset
,
1298 return handle
->fns
->recvfile(handle
, fromfd
, tofsp
, offset
, count
);
1301 int smb_vfs_call_rename(struct vfs_handle_struct
*handle
,
1302 const struct smb_filename
*smb_fname_src
,
1303 const struct smb_filename
*smb_fname_dst
)
1306 return handle
->fns
->rename(handle
, smb_fname_src
, smb_fname_dst
);
1309 int smb_vfs_call_fsync(struct vfs_handle_struct
*handle
,
1310 struct files_struct
*fsp
)
1313 return handle
->fns
->fsync(handle
, fsp
);
1316 int smb_vfs_call_stat(struct vfs_handle_struct
*handle
,
1317 struct smb_filename
*smb_fname
)
1320 return handle
->fns
->stat(handle
, smb_fname
);
1323 int smb_vfs_call_fstat(struct vfs_handle_struct
*handle
,
1324 struct files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
1327 return handle
->fns
->fstat(handle
, fsp
, sbuf
);
1330 int smb_vfs_call_lstat(struct vfs_handle_struct
*handle
,
1331 struct smb_filename
*smb_filename
)
1334 return handle
->fns
->lstat(handle
, smb_filename
);
1337 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct
*handle
,
1338 struct files_struct
*fsp
,
1339 const SMB_STRUCT_STAT
*sbuf
)
1341 VFS_FIND(get_alloc_size
);
1342 return handle
->fns
->get_alloc_size(handle
, fsp
, sbuf
);
1345 int smb_vfs_call_unlink(struct vfs_handle_struct
*handle
,
1346 const struct smb_filename
*smb_fname
)
1349 return handle
->fns
->unlink(handle
, smb_fname
);
1352 int smb_vfs_call_chmod(struct vfs_handle_struct
*handle
, const char *path
,
1356 return handle
->fns
->chmod(handle
, path
, mode
);
1359 int smb_vfs_call_fchmod(struct vfs_handle_struct
*handle
,
1360 struct files_struct
*fsp
, mode_t mode
)
1363 return handle
->fns
->fchmod(handle
, fsp
, mode
);
1366 int smb_vfs_call_chown(struct vfs_handle_struct
*handle
, const char *path
,
1367 uid_t uid
, gid_t gid
)
1370 return handle
->fns
->chown(handle
, path
, uid
, gid
);
1373 int smb_vfs_call_fchown(struct vfs_handle_struct
*handle
,
1374 struct files_struct
*fsp
, uid_t uid
, gid_t gid
)
1377 return handle
->fns
->fchown(handle
, fsp
, uid
, gid
);
1380 int smb_vfs_call_lchown(struct vfs_handle_struct
*handle
, const char *path
,
1381 uid_t uid
, gid_t gid
)
1384 return handle
->fns
->lchown(handle
, path
, uid
, gid
);
1387 int smb_vfs_call_chdir(struct vfs_handle_struct
*handle
, const char *path
)
1390 return handle
->fns
->chdir(handle
, path
);
1393 char *smb_vfs_call_getwd(struct vfs_handle_struct
*handle
, char *buf
)
1396 return handle
->fns
->getwd(handle
, buf
);
1399 int smb_vfs_call_ntimes(struct vfs_handle_struct
*handle
,
1400 const struct smb_filename
*smb_fname
,
1401 struct smb_file_time
*ft
)
1404 return handle
->fns
->ntimes(handle
, smb_fname
, ft
);
1407 int smb_vfs_call_ftruncate(struct vfs_handle_struct
*handle
,
1408 struct files_struct
*fsp
, SMB_OFF_T offset
)
1410 VFS_FIND(ftruncate
);
1411 return handle
->fns
->ftruncate(handle
, fsp
, offset
);
1414 int smb_vfs_call_kernel_flock(struct vfs_handle_struct
*handle
,
1415 struct files_struct
*fsp
, uint32 share_mode
,
1416 uint32_t access_mask
)
1418 VFS_FIND(kernel_flock
);
1419 return handle
->fns
->kernel_flock(handle
, fsp
, share_mode
,
1423 int smb_vfs_call_linux_setlease(struct vfs_handle_struct
*handle
,
1424 struct files_struct
*fsp
, int leasetype
)
1426 VFS_FIND(linux_setlease
);
1427 return handle
->fns
->linux_setlease(handle
, fsp
, leasetype
);
1430 int smb_vfs_call_symlink(struct vfs_handle_struct
*handle
, const char *oldpath
,
1431 const char *newpath
)
1434 return handle
->fns
->symlink(handle
, oldpath
, newpath
);
1437 int smb_vfs_call_vfs_readlink(struct vfs_handle_struct
*handle
,
1438 const char *path
, char *buf
, size_t bufsiz
)
1440 VFS_FIND(vfs_readlink
);
1441 return handle
->fns
->vfs_readlink(handle
, path
, buf
, bufsiz
);
1444 int smb_vfs_call_link(struct vfs_handle_struct
*handle
, const char *oldpath
,
1445 const char *newpath
)
1448 return handle
->fns
->link(handle
, oldpath
, newpath
);
1451 int smb_vfs_call_mknod(struct vfs_handle_struct
*handle
, const char *path
,
1452 mode_t mode
, SMB_DEV_T dev
)
1455 return handle
->fns
->mknod(handle
, path
, mode
, dev
);
1458 char *smb_vfs_call_realpath(struct vfs_handle_struct
*handle
, const char *path
)
1461 return handle
->fns
->realpath(handle
, path
);
1464 NTSTATUS
smb_vfs_call_notify_watch(struct vfs_handle_struct
*handle
,
1465 struct sys_notify_context
*ctx
,
1466 struct notify_entry
*e
,
1467 void (*callback
)(struct sys_notify_context
*ctx
,
1469 struct notify_event
*ev
),
1470 void *private_data
, void *handle_p
)
1472 VFS_FIND(notify_watch
);
1473 return handle
->fns
->notify_watch(handle
, ctx
, e
, callback
,
1474 private_data
, handle_p
);
1477 int smb_vfs_call_chflags(struct vfs_handle_struct
*handle
, const char *path
,
1481 return handle
->fns
->chflags(handle
, path
, flags
);
1484 struct file_id
smb_vfs_call_file_id_create(struct vfs_handle_struct
*handle
,
1485 const SMB_STRUCT_STAT
*sbuf
)
1487 VFS_FIND(file_id_create
);
1488 return handle
->fns
->file_id_create(handle
, sbuf
);
1491 NTSTATUS
smb_vfs_call_streaminfo(struct vfs_handle_struct
*handle
,
1492 struct files_struct
*fsp
,
1494 TALLOC_CTX
*mem_ctx
,
1495 unsigned int *num_streams
,
1496 struct stream_struct
**streams
)
1498 VFS_FIND(streaminfo
);
1499 return handle
->fns
->streaminfo(handle
, fsp
, fname
, mem_ctx
,
1500 num_streams
, streams
);
1503 int smb_vfs_call_get_real_filename(struct vfs_handle_struct
*handle
,
1504 const char *path
, const char *name
,
1505 TALLOC_CTX
*mem_ctx
, char **found_name
)
1507 VFS_FIND(get_real_filename
);
1508 return handle
->fns
->get_real_filename(handle
, path
, name
, mem_ctx
,
1512 const char *smb_vfs_call_connectpath(struct vfs_handle_struct
*handle
,
1513 const char *filename
)
1515 VFS_FIND(connectpath
);
1516 return handle
->fns
->connectpath(handle
, filename
);
1519 bool smb_vfs_call_strict_lock(struct vfs_handle_struct
*handle
,
1520 struct files_struct
*fsp
,
1521 struct lock_struct
*plock
)
1523 VFS_FIND(strict_lock
);
1524 return handle
->fns
->strict_lock(handle
, fsp
, plock
);
1527 void smb_vfs_call_strict_unlock(struct vfs_handle_struct
*handle
,
1528 struct files_struct
*fsp
,
1529 struct lock_struct
*plock
)
1531 VFS_FIND(strict_unlock
);
1532 handle
->fns
->strict_unlock(handle
, fsp
, plock
);
1535 NTSTATUS
smb_vfs_call_translate_name(struct vfs_handle_struct
*handle
,
1537 enum vfs_translate_direction direction
,
1538 TALLOC_CTX
*mem_ctx
,
1541 VFS_FIND(translate_name
);
1542 return handle
->fns
->translate_name(handle
, name
, direction
, mem_ctx
,
1546 NTSTATUS
smb_vfs_call_fget_nt_acl(struct vfs_handle_struct
*handle
,
1547 struct files_struct
*fsp
,
1548 uint32 security_info
,
1549 struct security_descriptor
**ppdesc
)
1551 VFS_FIND(fget_nt_acl
);
1552 return handle
->fns
->fget_nt_acl(handle
, fsp
, security_info
,
1556 NTSTATUS
smb_vfs_call_get_nt_acl(struct vfs_handle_struct
*handle
,
1558 uint32 security_info
,
1559 struct security_descriptor
**ppdesc
)
1561 VFS_FIND(get_nt_acl
);
1562 return handle
->fns
->get_nt_acl(handle
, name
, security_info
, ppdesc
);
1565 NTSTATUS
smb_vfs_call_fset_nt_acl(struct vfs_handle_struct
*handle
,
1566 struct files_struct
*fsp
,
1567 uint32 security_info_sent
,
1568 const struct security_descriptor
*psd
)
1570 VFS_FIND(fset_nt_acl
);
1571 return handle
->fns
->fset_nt_acl(handle
, fsp
, security_info_sent
, psd
);
1574 int smb_vfs_call_chmod_acl(struct vfs_handle_struct
*handle
, const char *name
,
1577 VFS_FIND(chmod_acl
);
1578 return handle
->fns
->chmod_acl(handle
, name
, mode
);
1581 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct
*handle
,
1582 struct files_struct
*fsp
, mode_t mode
)
1584 VFS_FIND(fchmod_acl
);
1585 return handle
->fns
->fchmod_acl(handle
, fsp
, mode
);
1588 int smb_vfs_call_sys_acl_get_entry(struct vfs_handle_struct
*handle
,
1589 SMB_ACL_T theacl
, int entry_id
,
1590 SMB_ACL_ENTRY_T
*entry_p
)
1592 VFS_FIND(sys_acl_get_entry
);
1593 return handle
->fns
->sys_acl_get_entry(handle
, theacl
, entry_id
,
1597 int smb_vfs_call_sys_acl_get_tag_type(struct vfs_handle_struct
*handle
,
1598 SMB_ACL_ENTRY_T entry_d
,
1599 SMB_ACL_TAG_T
*tag_type_p
)
1601 VFS_FIND(sys_acl_get_tag_type
);
1602 return handle
->fns
->sys_acl_get_tag_type(handle
, entry_d
, tag_type_p
);
1605 int smb_vfs_call_sys_acl_get_permset(struct vfs_handle_struct
*handle
,
1606 SMB_ACL_ENTRY_T entry_d
,
1607 SMB_ACL_PERMSET_T
*permset_p
)
1609 VFS_FIND(sys_acl_get_permset
);
1610 return handle
->fns
->sys_acl_get_permset(handle
, entry_d
, permset_p
);
1613 void * smb_vfs_call_sys_acl_get_qualifier(struct vfs_handle_struct
*handle
,
1614 SMB_ACL_ENTRY_T entry_d
)
1616 VFS_FIND(sys_acl_get_qualifier
);
1617 return handle
->fns
->sys_acl_get_qualifier(handle
, entry_d
);
1620 SMB_ACL_T
smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct
*handle
,
1622 SMB_ACL_TYPE_T type
)
1624 VFS_FIND(sys_acl_get_file
);
1625 return handle
->fns
->sys_acl_get_file(handle
, path_p
, type
);
1628 SMB_ACL_T
smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct
*handle
,
1629 struct files_struct
*fsp
)
1631 VFS_FIND(sys_acl_get_fd
);
1632 return handle
->fns
->sys_acl_get_fd(handle
, fsp
);
1635 int smb_vfs_call_sys_acl_clear_perms(struct vfs_handle_struct
*handle
,
1636 SMB_ACL_PERMSET_T permset
)
1638 VFS_FIND(sys_acl_clear_perms
);
1639 return handle
->fns
->sys_acl_clear_perms(handle
, permset
);
1642 int smb_vfs_call_sys_acl_add_perm(struct vfs_handle_struct
*handle
,
1643 SMB_ACL_PERMSET_T permset
,
1644 SMB_ACL_PERM_T perm
)
1646 VFS_FIND(sys_acl_add_perm
);
1647 return handle
->fns
->sys_acl_add_perm(handle
, permset
, perm
);
1650 char * smb_vfs_call_sys_acl_to_text(struct vfs_handle_struct
*handle
,
1651 SMB_ACL_T theacl
, ssize_t
*plen
)
1653 VFS_FIND(sys_acl_to_text
);
1654 return handle
->fns
->sys_acl_to_text(handle
, theacl
, plen
);
1657 SMB_ACL_T
smb_vfs_call_sys_acl_init(struct vfs_handle_struct
*handle
,
1660 VFS_FIND(sys_acl_init
);
1661 return handle
->fns
->sys_acl_init(handle
, count
);
1664 int smb_vfs_call_sys_acl_create_entry(struct vfs_handle_struct
*handle
,
1665 SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1667 VFS_FIND(sys_acl_create_entry
);
1668 return handle
->fns
->sys_acl_create_entry(handle
, pacl
, pentry
);
1671 int smb_vfs_call_sys_acl_set_tag_type(struct vfs_handle_struct
*handle
,
1672 SMB_ACL_ENTRY_T entry
,
1673 SMB_ACL_TAG_T tagtype
)
1675 VFS_FIND(sys_acl_set_tag_type
);
1676 return handle
->fns
->sys_acl_set_tag_type(handle
, entry
, tagtype
);
1679 int smb_vfs_call_sys_acl_set_qualifier(struct vfs_handle_struct
*handle
,
1680 SMB_ACL_ENTRY_T entry
, void *qual
)
1682 VFS_FIND(sys_acl_set_qualifier
);
1683 return handle
->fns
->sys_acl_set_qualifier(handle
, entry
, qual
);
1686 int smb_vfs_call_sys_acl_set_permset(struct vfs_handle_struct
*handle
,
1687 SMB_ACL_ENTRY_T entry
,
1688 SMB_ACL_PERMSET_T permset
)
1690 VFS_FIND(sys_acl_set_permset
);
1691 return handle
->fns
->sys_acl_set_permset(handle
, entry
, permset
);
1694 int smb_vfs_call_sys_acl_valid(struct vfs_handle_struct
*handle
,
1697 VFS_FIND(sys_acl_valid
);
1698 return handle
->fns
->sys_acl_valid(handle
, theacl
);
1701 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct
*handle
,
1702 const char *name
, SMB_ACL_TYPE_T acltype
,
1705 VFS_FIND(sys_acl_set_file
);
1706 return handle
->fns
->sys_acl_set_file(handle
, name
, acltype
, theacl
);
1709 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct
*handle
,
1710 struct files_struct
*fsp
, SMB_ACL_T theacl
)
1712 VFS_FIND(sys_acl_set_fd
);
1713 return handle
->fns
->sys_acl_set_fd(handle
, fsp
, theacl
);
1716 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct
*handle
,
1719 VFS_FIND(sys_acl_delete_def_file
);
1720 return handle
->fns
->sys_acl_delete_def_file(handle
, path
);
1723 int smb_vfs_call_sys_acl_get_perm(struct vfs_handle_struct
*handle
,
1724 SMB_ACL_PERMSET_T permset
,
1725 SMB_ACL_PERM_T perm
)
1727 VFS_FIND(sys_acl_get_perm
);
1728 return handle
->fns
->sys_acl_get_perm(handle
, permset
, perm
);
1731 int smb_vfs_call_sys_acl_free_text(struct vfs_handle_struct
*handle
,
1734 VFS_FIND(sys_acl_free_text
);
1735 return handle
->fns
->sys_acl_free_text(handle
, text
);
1738 int smb_vfs_call_sys_acl_free_acl(struct vfs_handle_struct
*handle
,
1739 SMB_ACL_T posix_acl
)
1741 VFS_FIND(sys_acl_free_acl
);
1742 return handle
->fns
->sys_acl_free_acl(handle
, posix_acl
);
1745 int smb_vfs_call_sys_acl_free_qualifier(struct vfs_handle_struct
*handle
,
1746 void *qualifier
, SMB_ACL_TAG_T tagtype
)
1748 VFS_FIND(sys_acl_free_qualifier
);
1749 return handle
->fns
->sys_acl_free_qualifier(handle
, qualifier
, tagtype
);
1752 ssize_t
smb_vfs_call_getxattr(struct vfs_handle_struct
*handle
,
1753 const char *path
, const char *name
, void *value
,
1757 return handle
->fns
->getxattr(handle
, path
, name
, value
, size
);
1760 ssize_t
smb_vfs_call_lgetxattr(struct vfs_handle_struct
*handle
,
1761 const char *path
, const char *name
, void *value
,
1764 VFS_FIND(lgetxattr
);
1765 return handle
->fns
->lgetxattr(handle
, path
, name
, value
, size
);
1768 ssize_t
smb_vfs_call_fgetxattr(struct vfs_handle_struct
*handle
,
1769 struct files_struct
*fsp
, const char *name
,
1770 void *value
, size_t size
)
1772 VFS_FIND(fgetxattr
);
1773 return handle
->fns
->fgetxattr(handle
, fsp
, name
, value
, size
);
1776 ssize_t
smb_vfs_call_listxattr(struct vfs_handle_struct
*handle
,
1777 const char *path
, char *list
, size_t size
)
1779 VFS_FIND(listxattr
);
1780 return handle
->fns
->listxattr(handle
, path
, list
, size
);
1783 ssize_t
smb_vfs_call_llistxattr(struct vfs_handle_struct
*handle
,
1784 const char *path
, char *list
, size_t size
)
1786 VFS_FIND(llistxattr
);
1787 return handle
->fns
->llistxattr(handle
, path
, list
, size
);
1790 ssize_t
smb_vfs_call_flistxattr(struct vfs_handle_struct
*handle
,
1791 struct files_struct
*fsp
, char *list
,
1794 VFS_FIND(flistxattr
);
1795 return handle
->fns
->flistxattr(handle
, fsp
, list
, size
);
1798 int smb_vfs_call_removexattr(struct vfs_handle_struct
*handle
,
1799 const char *path
, const char *name
)
1801 VFS_FIND(removexattr
);
1802 return handle
->fns
->removexattr(handle
, path
, name
);
1805 int smb_vfs_call_lremovexattr(struct vfs_handle_struct
*handle
,
1806 const char *path
, const char *name
)
1808 VFS_FIND(lremovexattr
);
1809 return handle
->fns
->lremovexattr(handle
, path
, name
);
1812 int smb_vfs_call_fremovexattr(struct vfs_handle_struct
*handle
,
1813 struct files_struct
*fsp
, const char *name
)
1815 VFS_FIND(fremovexattr
);
1816 return handle
->fns
->fremovexattr(handle
, fsp
, name
);
1819 int smb_vfs_call_setxattr(struct vfs_handle_struct
*handle
, const char *path
,
1820 const char *name
, const void *value
, size_t size
,
1824 return handle
->fns
->setxattr(handle
, path
, name
, value
, size
, flags
);
1827 int smb_vfs_call_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
,
1828 const char *name
, const void *value
, size_t size
,
1831 VFS_FIND(lsetxattr
);
1832 return handle
->fns
->lsetxattr(handle
, path
, name
, value
, size
, flags
);
1835 int smb_vfs_call_fsetxattr(struct vfs_handle_struct
*handle
,
1836 struct files_struct
*fsp
, const char *name
,
1837 const void *value
, size_t size
, int flags
)
1839 VFS_FIND(fsetxattr
);
1840 return handle
->fns
->fsetxattr(handle
, fsp
, name
, value
, size
, flags
);
1843 int smb_vfs_call_aio_read(struct vfs_handle_struct
*handle
,
1844 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1847 return handle
->fns
->aio_read(handle
, fsp
, aiocb
);
1850 int smb_vfs_call_aio_write(struct vfs_handle_struct
*handle
,
1851 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1853 VFS_FIND(aio_write
);
1854 return handle
->fns
->aio_write(handle
, fsp
, aiocb
);
1857 ssize_t
smb_vfs_call_aio_return_fn(struct vfs_handle_struct
*handle
,
1858 struct files_struct
*fsp
,
1859 SMB_STRUCT_AIOCB
*aiocb
)
1861 VFS_FIND(aio_return_fn
);
1862 return handle
->fns
->aio_return_fn(handle
, fsp
, aiocb
);
1865 int smb_vfs_call_aio_cancel(struct vfs_handle_struct
*handle
,
1866 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1868 VFS_FIND(aio_cancel
);
1869 return handle
->fns
->aio_cancel(handle
, fsp
, aiocb
);
1872 int smb_vfs_call_aio_error_fn(struct vfs_handle_struct
*handle
,
1873 struct files_struct
*fsp
,
1874 SMB_STRUCT_AIOCB
*aiocb
)
1876 VFS_FIND(aio_error_fn
);
1877 return handle
->fns
->aio_error_fn(handle
, fsp
, aiocb
);
1880 int smb_vfs_call_aio_fsync(struct vfs_handle_struct
*handle
,
1881 struct files_struct
*fsp
, int op
,
1882 SMB_STRUCT_AIOCB
*aiocb
)
1884 VFS_FIND(aio_fsync
);
1885 return handle
->fns
->aio_fsync(handle
, fsp
, op
, aiocb
);
1888 int smb_vfs_call_aio_suspend(struct vfs_handle_struct
*handle
,
1889 struct files_struct
*fsp
,
1890 const SMB_STRUCT_AIOCB
* const aiocb
[], int n
,
1891 const struct timespec
*timeout
)
1893 VFS_FIND(aio_suspend
);
1894 return handle
->fns
->aio_suspend(handle
, fsp
, aiocb
, n
, timeout
);
1897 bool smb_vfs_call_aio_force(struct vfs_handle_struct
*handle
,
1898 struct files_struct
*fsp
)
1900 VFS_FIND(aio_force
);
1901 return handle
->fns
->aio_force(handle
, fsp
);
1904 bool smb_vfs_call_is_offline(struct vfs_handle_struct
*handle
,
1905 const char *path
, SMB_STRUCT_STAT
*sbuf
)
1907 VFS_FIND(is_offline
);
1908 return handle
->fns
->is_offline(handle
, path
, sbuf
);
1911 int smb_vfs_call_set_offline(struct vfs_handle_struct
*handle
,
1914 VFS_FIND(set_offline
);
1915 return handle
->fns
->set_offline(handle
, path
);