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 #ifdef REALPATH_TAKES_NULL
845 bool free_resolved_name
= True
;
847 char resolved_name_buf
[PATH_MAX
+1];
848 bool free_resolved_name
= False
;
850 char *resolved_name
= NULL
;
853 DEBUG(3,("check_reduced_name [%s] [%s]\n", fname
, conn
->connectpath
));
855 #ifdef REALPATH_TAKES_NULL
856 resolved_name
= SMB_VFS_REALPATH(conn
,fname
,NULL
);
858 resolved_name
= SMB_VFS_REALPATH(conn
,fname
,resolved_name_buf
);
861 if (!resolved_name
) {
864 DEBUG(3,("check_reduced_name: Component not a "
865 "directory in getting realpath for "
867 return NT_STATUS_OBJECT_PATH_NOT_FOUND
;
870 TALLOC_CTX
*ctx
= talloc_tos();
871 char *tmp_fname
= NULL
;
872 char *last_component
= NULL
;
873 /* Last component didn't exist. Remove it and try and canonicalise the directory. */
875 tmp_fname
= talloc_strdup(ctx
, fname
);
877 return NT_STATUS_NO_MEMORY
;
879 p
= strrchr_m(tmp_fname
, '/');
884 last_component
= tmp_fname
;
885 tmp_fname
= talloc_strdup(ctx
,
888 return NT_STATUS_NO_MEMORY
;
892 #ifdef REALPATH_TAKES_NULL
893 resolved_name
= SMB_VFS_REALPATH(conn
,tmp_fname
,NULL
);
895 resolved_name
= SMB_VFS_REALPATH(conn
,tmp_fname
,resolved_name_buf
);
897 if (!resolved_name
) {
898 NTSTATUS status
= map_nt_error_from_unix(errno
);
900 if (errno
== ENOENT
|| errno
== ENOTDIR
) {
901 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
904 DEBUG(3,("check_reduce_named: "
905 "couldn't get realpath for "
911 tmp_fname
= talloc_asprintf(ctx
,
916 return NT_STATUS_NO_MEMORY
;
918 #ifdef REALPATH_TAKES_NULL
919 SAFE_FREE(resolved_name
);
920 resolved_name
= SMB_STRDUP(tmp_fname
);
921 if (!resolved_name
) {
922 DEBUG(0, ("check_reduced_name: malloc "
923 "fail for %s\n", tmp_fname
));
924 return NT_STATUS_NO_MEMORY
;
927 safe_strcpy(resolved_name_buf
, tmp_fname
, PATH_MAX
);
928 resolved_name
= resolved_name_buf
;
933 DEBUG(1,("check_reduced_name: couldn't get "
934 "realpath for %s\n", fname
));
935 return map_nt_error_from_unix(errno
);
939 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname
,
942 if (*resolved_name
!= '/') {
943 DEBUG(0,("check_reduced_name: realpath doesn't return "
944 "absolute paths !\n"));
945 if (free_resolved_name
) {
946 SAFE_FREE(resolved_name
);
948 return NT_STATUS_OBJECT_NAME_INVALID
;
951 /* Check for widelinks allowed. */
952 if (!lp_widelinks(SNUM(conn
))) {
953 const char *conn_rootdir
;
955 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, fname
);
956 if (conn_rootdir
== NULL
) {
957 DEBUG(2, ("check_reduced_name: Could not get "
959 if (free_resolved_name
) {
960 SAFE_FREE(resolved_name
);
962 return NT_STATUS_ACCESS_DENIED
;
965 if (strncmp(conn_rootdir
, resolved_name
,
966 strlen(conn_rootdir
)) != 0) {
967 DEBUG(2, ("check_reduced_name: Bad access "
968 "attempt: %s is a symlink outside the "
969 "share path\n", fname
));
970 if (free_resolved_name
) {
971 SAFE_FREE(resolved_name
);
973 return NT_STATUS_ACCESS_DENIED
;
977 /* Check if we are allowing users to follow symlinks */
978 /* Patch from David Clerc <David.Clerc@cui.unige.ch>
979 University of Geneva */
982 if (!lp_symlinks(SNUM(conn
))) {
983 struct smb_filename
*smb_fname
= NULL
;
986 status
= create_synthetic_smb_fname(talloc_tos(), fname
, NULL
,
988 if (!NT_STATUS_IS_OK(status
)) {
989 if (free_resolved_name
) {
990 SAFE_FREE(resolved_name
);
995 if ( (SMB_VFS_LSTAT(conn
, smb_fname
) != -1) &&
996 (S_ISLNK(smb_fname
->st
.st_ex_mode
)) ) {
997 if (free_resolved_name
) {
998 SAFE_FREE(resolved_name
);
1000 DEBUG(3,("check_reduced_name: denied: file path name "
1001 "%s is a symlink\n",resolved_name
));
1002 TALLOC_FREE(smb_fname
);
1003 return NT_STATUS_ACCESS_DENIED
;
1005 TALLOC_FREE(smb_fname
);
1009 DEBUG(3,("check_reduced_name: %s reduced to %s\n", fname
,
1011 if (free_resolved_name
) {
1012 SAFE_FREE(resolved_name
);
1014 return NT_STATUS_OK
;
1018 * XXX: This is temporary and there should be no callers of this once
1019 * smb_filename is plumbed through all path based operations.
1021 int vfs_stat_smb_fname(struct connection_struct
*conn
, const char *fname
,
1022 SMB_STRUCT_STAT
*psbuf
)
1024 struct smb_filename
*smb_fname
= NULL
;
1028 status
= create_synthetic_smb_fname_split(talloc_tos(), fname
, NULL
,
1030 if (!NT_STATUS_IS_OK(status
)) {
1031 errno
= map_errno_from_nt_status(status
);
1035 if (lp_posix_pathnames()) {
1036 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
1038 ret
= SMB_VFS_STAT(conn
, smb_fname
);
1042 *psbuf
= smb_fname
->st
;
1045 TALLOC_FREE(smb_fname
);
1050 * XXX: This is temporary and there should be no callers of this once
1051 * smb_filename is plumbed through all path based operations.
1053 int vfs_lstat_smb_fname(struct connection_struct
*conn
, const char *fname
,
1054 SMB_STRUCT_STAT
*psbuf
)
1056 struct smb_filename
*smb_fname
= NULL
;
1060 status
= create_synthetic_smb_fname_split(talloc_tos(), fname
, NULL
,
1062 if (!NT_STATUS_IS_OK(status
)) {
1063 errno
= map_errno_from_nt_status(status
);
1067 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
1069 *psbuf
= smb_fname
->st
;
1072 TALLOC_FREE(smb_fname
);
1077 * Ensure LSTAT is called for POSIX paths.
1080 NTSTATUS
vfs_stat_fsp(files_struct
*fsp
)
1084 if(fsp
->is_directory
|| fsp
->fh
->fd
== -1) {
1085 if (fsp
->posix_open
) {
1086 ret
= SMB_VFS_LSTAT(fsp
->conn
, fsp
->fsp_name
);
1088 ret
= SMB_VFS_STAT(fsp
->conn
, fsp
->fsp_name
);
1091 return map_nt_error_from_unix(errno
);
1094 if(SMB_VFS_FSTAT(fsp
, &fsp
->fsp_name
->st
) != 0) {
1095 return map_nt_error_from_unix(errno
);
1098 return NT_STATUS_OK
;
1102 generate a file_id from a stat structure
1104 struct file_id
vfs_file_id_from_sbuf(connection_struct
*conn
, const SMB_STRUCT_STAT
*sbuf
)
1106 return SMB_VFS_FILE_ID_CREATE(conn
, sbuf
);
1109 int smb_vfs_call_connect(struct vfs_handle_struct
*handle
,
1110 const char *service
, const char *user
)
1112 VFS_FIND(connect_fn
);
1113 return handle
->fns
->connect_fn(handle
, service
, user
);
1116 void smb_vfs_call_disconnect(struct vfs_handle_struct
*handle
)
1118 VFS_FIND(disconnect
);
1119 handle
->fns
->disconnect(handle
);
1122 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct
*handle
,
1123 const char *path
, bool small_query
,
1124 uint64_t *bsize
, uint64_t *dfree
,
1127 VFS_FIND(disk_free
);
1128 return handle
->fns
->disk_free(handle
, path
, small_query
, bsize
, dfree
,
1132 int smb_vfs_call_get_quota(struct vfs_handle_struct
*handle
,
1133 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1136 VFS_FIND(get_quota
);
1137 return handle
->fns
->get_quota(handle
, qtype
, id
, qt
);
1140 int smb_vfs_call_set_quota(struct vfs_handle_struct
*handle
,
1141 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
1144 VFS_FIND(set_quota
);
1145 return handle
->fns
->set_quota(handle
, qtype
, id
, qt
);
1148 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
1149 struct files_struct
*fsp
,
1150 SHADOW_COPY_DATA
*shadow_copy_data
,
1153 VFS_FIND(get_shadow_copy_data
);
1154 return handle
->fns
->get_shadow_copy_data(handle
, fsp
, shadow_copy_data
,
1157 int smb_vfs_call_statvfs(struct vfs_handle_struct
*handle
, const char *path
,
1158 struct vfs_statvfs_struct
*statbuf
)
1161 return handle
->fns
->statvfs(handle
, path
, statbuf
);
1164 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct
*handle
,
1165 enum timestamp_set_resolution
*p_ts_res
)
1167 VFS_FIND(fs_capabilities
);
1168 return handle
->fns
->fs_capabilities(handle
, p_ts_res
);
1171 SMB_STRUCT_DIR
*smb_vfs_call_opendir(struct vfs_handle_struct
*handle
,
1172 const char *fname
, const char *mask
,
1176 return handle
->fns
->opendir(handle
, fname
, mask
, attributes
);
1179 SMB_STRUCT_DIRENT
*smb_vfs_call_readdir(struct vfs_handle_struct
*handle
,
1180 SMB_STRUCT_DIR
*dirp
,
1181 SMB_STRUCT_STAT
*sbuf
)
1184 return handle
->fns
->readdir(handle
, dirp
, sbuf
);
1187 void smb_vfs_call_seekdir(struct vfs_handle_struct
*handle
,
1188 SMB_STRUCT_DIR
*dirp
, long offset
)
1191 handle
->fns
->seekdir(handle
, dirp
, offset
);
1194 long smb_vfs_call_telldir(struct vfs_handle_struct
*handle
,
1195 SMB_STRUCT_DIR
*dirp
)
1198 return handle
->fns
->telldir(handle
, dirp
);
1201 void smb_vfs_call_rewind_dir(struct vfs_handle_struct
*handle
,
1202 SMB_STRUCT_DIR
*dirp
)
1204 VFS_FIND(rewind_dir
);
1205 handle
->fns
->rewind_dir(handle
, dirp
);
1208 int smb_vfs_call_mkdir(struct vfs_handle_struct
*handle
, const char *path
,
1212 return handle
->fns
->mkdir(handle
, path
, mode
);
1215 int smb_vfs_call_rmdir(struct vfs_handle_struct
*handle
, const char *path
)
1218 return handle
->fns
->rmdir(handle
, path
);
1221 int smb_vfs_call_closedir(struct vfs_handle_struct
*handle
,
1222 SMB_STRUCT_DIR
*dir
)
1225 return handle
->fns
->closedir(handle
, dir
);
1228 void smb_vfs_call_init_search_op(struct vfs_handle_struct
*handle
,
1229 SMB_STRUCT_DIR
*dirp
)
1231 VFS_FIND(init_search_op
);
1232 handle
->fns
->init_search_op(handle
, dirp
);
1235 int smb_vfs_call_open(struct vfs_handle_struct
*handle
,
1236 struct smb_filename
*smb_fname
, struct files_struct
*fsp
,
1237 int flags
, mode_t mode
)
1240 return handle
->fns
->open(handle
, smb_fname
, fsp
, flags
, mode
);
1243 NTSTATUS
smb_vfs_call_create_file(struct vfs_handle_struct
*handle
,
1244 struct smb_request
*req
,
1245 uint16_t root_dir_fid
,
1246 struct smb_filename
*smb_fname
,
1247 uint32_t access_mask
,
1248 uint32_t share_access
,
1249 uint32_t create_disposition
,
1250 uint32_t create_options
,
1251 uint32_t file_attributes
,
1252 uint32_t oplock_request
,
1253 uint64_t allocation_size
,
1254 uint32_t private_flags
,
1255 struct security_descriptor
*sd
,
1256 struct ea_list
*ea_list
,
1257 files_struct
**result
,
1260 VFS_FIND(create_file
);
1261 return handle
->fns
->create_file(
1262 handle
, req
, root_dir_fid
, smb_fname
, access_mask
,
1263 share_access
, create_disposition
, create_options
,
1264 file_attributes
, oplock_request
, allocation_size
,
1265 private_flags
, sd
, ea_list
,
1269 int smb_vfs_call_close_fn(struct vfs_handle_struct
*handle
,
1270 struct files_struct
*fsp
)
1273 return handle
->fns
->close_fn(handle
, fsp
);
1276 ssize_t
smb_vfs_call_vfs_read(struct vfs_handle_struct
*handle
,
1277 struct files_struct
*fsp
, void *data
, size_t n
)
1280 return handle
->fns
->vfs_read(handle
, fsp
, data
, n
);
1283 ssize_t
smb_vfs_call_pread(struct vfs_handle_struct
*handle
,
1284 struct files_struct
*fsp
, void *data
, size_t n
,
1288 return handle
->fns
->pread(handle
, fsp
, data
, n
, offset
);
1291 ssize_t
smb_vfs_call_write(struct vfs_handle_struct
*handle
,
1292 struct files_struct
*fsp
, const void *data
,
1296 return handle
->fns
->write(handle
, fsp
, data
, n
);
1299 ssize_t
smb_vfs_call_pwrite(struct vfs_handle_struct
*handle
,
1300 struct files_struct
*fsp
, const void *data
,
1301 size_t n
, SMB_OFF_T offset
)
1304 return handle
->fns
->pwrite(handle
, fsp
, data
, n
, offset
);
1307 SMB_OFF_T
smb_vfs_call_lseek(struct vfs_handle_struct
*handle
,
1308 struct files_struct
*fsp
, SMB_OFF_T offset
,
1312 return handle
->fns
->lseek(handle
, fsp
, offset
, whence
);
1315 ssize_t
smb_vfs_call_sendfile(struct vfs_handle_struct
*handle
, int tofd
,
1316 files_struct
*fromfsp
, const DATA_BLOB
*header
,
1317 SMB_OFF_T offset
, size_t count
)
1320 return handle
->fns
->sendfile(handle
, tofd
, fromfsp
, header
, offset
,
1324 ssize_t
smb_vfs_call_recvfile(struct vfs_handle_struct
*handle
, int fromfd
,
1325 files_struct
*tofsp
, SMB_OFF_T offset
,
1329 return handle
->fns
->recvfile(handle
, fromfd
, tofsp
, offset
, count
);
1332 int smb_vfs_call_rename(struct vfs_handle_struct
*handle
,
1333 const struct smb_filename
*smb_fname_src
,
1334 const struct smb_filename
*smb_fname_dst
)
1337 return handle
->fns
->rename(handle
, smb_fname_src
, smb_fname_dst
);
1340 int smb_vfs_call_fsync(struct vfs_handle_struct
*handle
,
1341 struct files_struct
*fsp
)
1344 return handle
->fns
->fsync(handle
, fsp
);
1347 int smb_vfs_call_stat(struct vfs_handle_struct
*handle
,
1348 struct smb_filename
*smb_fname
)
1351 return handle
->fns
->stat(handle
, smb_fname
);
1354 int smb_vfs_call_fstat(struct vfs_handle_struct
*handle
,
1355 struct files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
1358 return handle
->fns
->fstat(handle
, fsp
, sbuf
);
1361 int smb_vfs_call_lstat(struct vfs_handle_struct
*handle
,
1362 struct smb_filename
*smb_filename
)
1365 return handle
->fns
->lstat(handle
, smb_filename
);
1368 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct
*handle
,
1369 struct files_struct
*fsp
,
1370 const SMB_STRUCT_STAT
*sbuf
)
1372 VFS_FIND(get_alloc_size
);
1373 return handle
->fns
->get_alloc_size(handle
, fsp
, sbuf
);
1376 int smb_vfs_call_unlink(struct vfs_handle_struct
*handle
,
1377 const struct smb_filename
*smb_fname
)
1380 return handle
->fns
->unlink(handle
, smb_fname
);
1383 int smb_vfs_call_chmod(struct vfs_handle_struct
*handle
, const char *path
,
1387 return handle
->fns
->chmod(handle
, path
, mode
);
1390 int smb_vfs_call_fchmod(struct vfs_handle_struct
*handle
,
1391 struct files_struct
*fsp
, mode_t mode
)
1394 return handle
->fns
->fchmod(handle
, fsp
, mode
);
1397 int smb_vfs_call_chown(struct vfs_handle_struct
*handle
, const char *path
,
1398 uid_t uid
, gid_t gid
)
1401 return handle
->fns
->chown(handle
, path
, uid
, gid
);
1404 int smb_vfs_call_fchown(struct vfs_handle_struct
*handle
,
1405 struct files_struct
*fsp
, uid_t uid
, gid_t gid
)
1408 return handle
->fns
->fchown(handle
, fsp
, uid
, gid
);
1411 int smb_vfs_call_lchown(struct vfs_handle_struct
*handle
, const char *path
,
1412 uid_t uid
, gid_t gid
)
1415 return handle
->fns
->lchown(handle
, path
, uid
, gid
);
1418 int smb_vfs_call_chdir(struct vfs_handle_struct
*handle
, const char *path
)
1421 return handle
->fns
->chdir(handle
, path
);
1424 char *smb_vfs_call_getwd(struct vfs_handle_struct
*handle
, char *buf
)
1427 return handle
->fns
->getwd(handle
, buf
);
1430 int smb_vfs_call_ntimes(struct vfs_handle_struct
*handle
,
1431 const struct smb_filename
*smb_fname
,
1432 struct smb_file_time
*ft
)
1435 return handle
->fns
->ntimes(handle
, smb_fname
, ft
);
1438 int smb_vfs_call_ftruncate(struct vfs_handle_struct
*handle
,
1439 struct files_struct
*fsp
, SMB_OFF_T offset
)
1441 VFS_FIND(ftruncate
);
1442 return handle
->fns
->ftruncate(handle
, fsp
, offset
);
1445 int smb_vfs_call_kernel_flock(struct vfs_handle_struct
*handle
,
1446 struct files_struct
*fsp
, uint32 share_mode
,
1447 uint32_t access_mask
)
1449 VFS_FIND(kernel_flock
);
1450 return handle
->fns
->kernel_flock(handle
, fsp
, share_mode
,
1454 int smb_vfs_call_linux_setlease(struct vfs_handle_struct
*handle
,
1455 struct files_struct
*fsp
, int leasetype
)
1457 VFS_FIND(linux_setlease
);
1458 return handle
->fns
->linux_setlease(handle
, fsp
, leasetype
);
1461 int smb_vfs_call_symlink(struct vfs_handle_struct
*handle
, const char *oldpath
,
1462 const char *newpath
)
1465 return handle
->fns
->symlink(handle
, oldpath
, newpath
);
1468 int smb_vfs_call_vfs_readlink(struct vfs_handle_struct
*handle
,
1469 const char *path
, char *buf
, size_t bufsiz
)
1471 VFS_FIND(vfs_readlink
);
1472 return handle
->fns
->vfs_readlink(handle
, path
, buf
, bufsiz
);
1475 int smb_vfs_call_link(struct vfs_handle_struct
*handle
, const char *oldpath
,
1476 const char *newpath
)
1479 return handle
->fns
->link(handle
, oldpath
, newpath
);
1482 int smb_vfs_call_mknod(struct vfs_handle_struct
*handle
, const char *path
,
1483 mode_t mode
, SMB_DEV_T dev
)
1486 return handle
->fns
->mknod(handle
, path
, mode
, dev
);
1489 char *smb_vfs_call_realpath(struct vfs_handle_struct
*handle
,
1490 const char *path
, char *resolved_path
)
1493 return handle
->fns
->realpath(handle
, path
, resolved_path
);
1496 NTSTATUS
smb_vfs_call_notify_watch(struct vfs_handle_struct
*handle
,
1497 struct sys_notify_context
*ctx
,
1498 struct notify_entry
*e
,
1499 void (*callback
)(struct sys_notify_context
*ctx
,
1501 struct notify_event
*ev
),
1502 void *private_data
, void *handle_p
)
1504 VFS_FIND(notify_watch
);
1505 return handle
->fns
->notify_watch(handle
, ctx
, e
, callback
,
1506 private_data
, handle_p
);
1509 int smb_vfs_call_chflags(struct vfs_handle_struct
*handle
, const char *path
,
1513 return handle
->fns
->chflags(handle
, path
, flags
);
1516 struct file_id
smb_vfs_call_file_id_create(struct vfs_handle_struct
*handle
,
1517 const SMB_STRUCT_STAT
*sbuf
)
1519 VFS_FIND(file_id_create
);
1520 return handle
->fns
->file_id_create(handle
, sbuf
);
1523 NTSTATUS
smb_vfs_call_streaminfo(struct vfs_handle_struct
*handle
,
1524 struct files_struct
*fsp
,
1526 TALLOC_CTX
*mem_ctx
,
1527 unsigned int *num_streams
,
1528 struct stream_struct
**streams
)
1530 VFS_FIND(streaminfo
);
1531 return handle
->fns
->streaminfo(handle
, fsp
, fname
, mem_ctx
,
1532 num_streams
, streams
);
1535 int smb_vfs_call_get_real_filename(struct vfs_handle_struct
*handle
,
1536 const char *path
, const char *name
,
1537 TALLOC_CTX
*mem_ctx
, char **found_name
)
1539 VFS_FIND(get_real_filename
);
1540 return handle
->fns
->get_real_filename(handle
, path
, name
, mem_ctx
,
1544 const char *smb_vfs_call_connectpath(struct vfs_handle_struct
*handle
,
1545 const char *filename
)
1547 VFS_FIND(connectpath
);
1548 return handle
->fns
->connectpath(handle
, filename
);
1551 bool smb_vfs_call_strict_lock(struct vfs_handle_struct
*handle
,
1552 struct files_struct
*fsp
,
1553 struct lock_struct
*plock
)
1555 VFS_FIND(strict_lock
);
1556 return handle
->fns
->strict_lock(handle
, fsp
, plock
);
1559 void smb_vfs_call_strict_unlock(struct vfs_handle_struct
*handle
,
1560 struct files_struct
*fsp
,
1561 struct lock_struct
*plock
)
1563 VFS_FIND(strict_unlock
);
1564 handle
->fns
->strict_unlock(handle
, fsp
, plock
);
1567 NTSTATUS
smb_vfs_call_translate_name(struct vfs_handle_struct
*handle
,
1569 enum vfs_translate_direction direction
,
1570 TALLOC_CTX
*mem_ctx
,
1573 VFS_FIND(translate_name
);
1574 return handle
->fns
->translate_name(handle
, name
, direction
, mem_ctx
,
1578 NTSTATUS
smb_vfs_call_fget_nt_acl(struct vfs_handle_struct
*handle
,
1579 struct files_struct
*fsp
,
1580 uint32 security_info
,
1581 struct security_descriptor
**ppdesc
)
1583 VFS_FIND(fget_nt_acl
);
1584 return handle
->fns
->fget_nt_acl(handle
, fsp
, security_info
,
1588 NTSTATUS
smb_vfs_call_get_nt_acl(struct vfs_handle_struct
*handle
,
1590 uint32 security_info
,
1591 struct security_descriptor
**ppdesc
)
1593 VFS_FIND(get_nt_acl
);
1594 return handle
->fns
->get_nt_acl(handle
, name
, security_info
, ppdesc
);
1597 NTSTATUS
smb_vfs_call_fset_nt_acl(struct vfs_handle_struct
*handle
,
1598 struct files_struct
*fsp
,
1599 uint32 security_info_sent
,
1600 const struct security_descriptor
*psd
)
1602 VFS_FIND(fset_nt_acl
);
1603 return handle
->fns
->fset_nt_acl(handle
, fsp
, security_info_sent
, psd
);
1606 int smb_vfs_call_chmod_acl(struct vfs_handle_struct
*handle
, const char *name
,
1609 VFS_FIND(chmod_acl
);
1610 return handle
->fns
->chmod_acl(handle
, name
, mode
);
1613 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct
*handle
,
1614 struct files_struct
*fsp
, mode_t mode
)
1616 VFS_FIND(fchmod_acl
);
1617 return handle
->fns
->fchmod_acl(handle
, fsp
, mode
);
1620 int smb_vfs_call_sys_acl_get_entry(struct vfs_handle_struct
*handle
,
1621 SMB_ACL_T theacl
, int entry_id
,
1622 SMB_ACL_ENTRY_T
*entry_p
)
1624 VFS_FIND(sys_acl_get_entry
);
1625 return handle
->fns
->sys_acl_get_entry(handle
, theacl
, entry_id
,
1629 int smb_vfs_call_sys_acl_get_tag_type(struct vfs_handle_struct
*handle
,
1630 SMB_ACL_ENTRY_T entry_d
,
1631 SMB_ACL_TAG_T
*tag_type_p
)
1633 VFS_FIND(sys_acl_get_tag_type
);
1634 return handle
->fns
->sys_acl_get_tag_type(handle
, entry_d
, tag_type_p
);
1637 int smb_vfs_call_sys_acl_get_permset(struct vfs_handle_struct
*handle
,
1638 SMB_ACL_ENTRY_T entry_d
,
1639 SMB_ACL_PERMSET_T
*permset_p
)
1641 VFS_FIND(sys_acl_get_permset
);
1642 return handle
->fns
->sys_acl_get_permset(handle
, entry_d
, permset_p
);
1645 void * smb_vfs_call_sys_acl_get_qualifier(struct vfs_handle_struct
*handle
,
1646 SMB_ACL_ENTRY_T entry_d
)
1648 VFS_FIND(sys_acl_get_qualifier
);
1649 return handle
->fns
->sys_acl_get_qualifier(handle
, entry_d
);
1652 SMB_ACL_T
smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct
*handle
,
1654 SMB_ACL_TYPE_T type
)
1656 VFS_FIND(sys_acl_get_file
);
1657 return handle
->fns
->sys_acl_get_file(handle
, path_p
, type
);
1660 SMB_ACL_T
smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct
*handle
,
1661 struct files_struct
*fsp
)
1663 VFS_FIND(sys_acl_get_fd
);
1664 return handle
->fns
->sys_acl_get_fd(handle
, fsp
);
1667 int smb_vfs_call_sys_acl_clear_perms(struct vfs_handle_struct
*handle
,
1668 SMB_ACL_PERMSET_T permset
)
1670 VFS_FIND(sys_acl_clear_perms
);
1671 return handle
->fns
->sys_acl_clear_perms(handle
, permset
);
1674 int smb_vfs_call_sys_acl_add_perm(struct vfs_handle_struct
*handle
,
1675 SMB_ACL_PERMSET_T permset
,
1676 SMB_ACL_PERM_T perm
)
1678 VFS_FIND(sys_acl_add_perm
);
1679 return handle
->fns
->sys_acl_add_perm(handle
, permset
, perm
);
1682 char * smb_vfs_call_sys_acl_to_text(struct vfs_handle_struct
*handle
,
1683 SMB_ACL_T theacl
, ssize_t
*plen
)
1685 VFS_FIND(sys_acl_to_text
);
1686 return handle
->fns
->sys_acl_to_text(handle
, theacl
, plen
);
1689 SMB_ACL_T
smb_vfs_call_sys_acl_init(struct vfs_handle_struct
*handle
,
1692 VFS_FIND(sys_acl_init
);
1693 return handle
->fns
->sys_acl_init(handle
, count
);
1696 int smb_vfs_call_sys_acl_create_entry(struct vfs_handle_struct
*handle
,
1697 SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1699 VFS_FIND(sys_acl_create_entry
);
1700 return handle
->fns
->sys_acl_create_entry(handle
, pacl
, pentry
);
1703 int smb_vfs_call_sys_acl_set_tag_type(struct vfs_handle_struct
*handle
,
1704 SMB_ACL_ENTRY_T entry
,
1705 SMB_ACL_TAG_T tagtype
)
1707 VFS_FIND(sys_acl_set_tag_type
);
1708 return handle
->fns
->sys_acl_set_tag_type(handle
, entry
, tagtype
);
1711 int smb_vfs_call_sys_acl_set_qualifier(struct vfs_handle_struct
*handle
,
1712 SMB_ACL_ENTRY_T entry
, void *qual
)
1714 VFS_FIND(sys_acl_set_qualifier
);
1715 return handle
->fns
->sys_acl_set_qualifier(handle
, entry
, qual
);
1718 int smb_vfs_call_sys_acl_set_permset(struct vfs_handle_struct
*handle
,
1719 SMB_ACL_ENTRY_T entry
,
1720 SMB_ACL_PERMSET_T permset
)
1722 VFS_FIND(sys_acl_set_permset
);
1723 return handle
->fns
->sys_acl_set_permset(handle
, entry
, permset
);
1726 int smb_vfs_call_sys_acl_valid(struct vfs_handle_struct
*handle
,
1729 VFS_FIND(sys_acl_valid
);
1730 return handle
->fns
->sys_acl_valid(handle
, theacl
);
1733 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct
*handle
,
1734 const char *name
, SMB_ACL_TYPE_T acltype
,
1737 VFS_FIND(sys_acl_set_file
);
1738 return handle
->fns
->sys_acl_set_file(handle
, name
, acltype
, theacl
);
1741 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct
*handle
,
1742 struct files_struct
*fsp
, SMB_ACL_T theacl
)
1744 VFS_FIND(sys_acl_set_fd
);
1745 return handle
->fns
->sys_acl_set_fd(handle
, fsp
, theacl
);
1748 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct
*handle
,
1751 VFS_FIND(sys_acl_delete_def_file
);
1752 return handle
->fns
->sys_acl_delete_def_file(handle
, path
);
1755 int smb_vfs_call_sys_acl_get_perm(struct vfs_handle_struct
*handle
,
1756 SMB_ACL_PERMSET_T permset
,
1757 SMB_ACL_PERM_T perm
)
1759 VFS_FIND(sys_acl_get_perm
);
1760 return handle
->fns
->sys_acl_get_perm(handle
, permset
, perm
);
1763 int smb_vfs_call_sys_acl_free_text(struct vfs_handle_struct
*handle
,
1766 VFS_FIND(sys_acl_free_text
);
1767 return handle
->fns
->sys_acl_free_text(handle
, text
);
1770 int smb_vfs_call_sys_acl_free_acl(struct vfs_handle_struct
*handle
,
1771 SMB_ACL_T posix_acl
)
1773 VFS_FIND(sys_acl_free_acl
);
1774 return handle
->fns
->sys_acl_free_acl(handle
, posix_acl
);
1777 int smb_vfs_call_sys_acl_free_qualifier(struct vfs_handle_struct
*handle
,
1778 void *qualifier
, SMB_ACL_TAG_T tagtype
)
1780 VFS_FIND(sys_acl_free_qualifier
);
1781 return handle
->fns
->sys_acl_free_qualifier(handle
, qualifier
, tagtype
);
1784 ssize_t
smb_vfs_call_getxattr(struct vfs_handle_struct
*handle
,
1785 const char *path
, const char *name
, void *value
,
1789 return handle
->fns
->getxattr(handle
, path
, name
, value
, size
);
1792 ssize_t
smb_vfs_call_lgetxattr(struct vfs_handle_struct
*handle
,
1793 const char *path
, const char *name
, void *value
,
1796 VFS_FIND(lgetxattr
);
1797 return handle
->fns
->lgetxattr(handle
, path
, name
, value
, size
);
1800 ssize_t
smb_vfs_call_fgetxattr(struct vfs_handle_struct
*handle
,
1801 struct files_struct
*fsp
, const char *name
,
1802 void *value
, size_t size
)
1804 VFS_FIND(fgetxattr
);
1805 return handle
->fns
->fgetxattr(handle
, fsp
, name
, value
, size
);
1808 ssize_t
smb_vfs_call_listxattr(struct vfs_handle_struct
*handle
,
1809 const char *path
, char *list
, size_t size
)
1811 VFS_FIND(listxattr
);
1812 return handle
->fns
->listxattr(handle
, path
, list
, size
);
1815 ssize_t
smb_vfs_call_llistxattr(struct vfs_handle_struct
*handle
,
1816 const char *path
, char *list
, size_t size
)
1818 VFS_FIND(llistxattr
);
1819 return handle
->fns
->llistxattr(handle
, path
, list
, size
);
1822 ssize_t
smb_vfs_call_flistxattr(struct vfs_handle_struct
*handle
,
1823 struct files_struct
*fsp
, char *list
,
1826 VFS_FIND(flistxattr
);
1827 return handle
->fns
->flistxattr(handle
, fsp
, list
, size
);
1830 int smb_vfs_call_removexattr(struct vfs_handle_struct
*handle
,
1831 const char *path
, const char *name
)
1833 VFS_FIND(removexattr
);
1834 return handle
->fns
->removexattr(handle
, path
, name
);
1837 int smb_vfs_call_lremovexattr(struct vfs_handle_struct
*handle
,
1838 const char *path
, const char *name
)
1840 VFS_FIND(lremovexattr
);
1841 return handle
->fns
->lremovexattr(handle
, path
, name
);
1844 int smb_vfs_call_fremovexattr(struct vfs_handle_struct
*handle
,
1845 struct files_struct
*fsp
, const char *name
)
1847 VFS_FIND(fremovexattr
);
1848 return handle
->fns
->fremovexattr(handle
, fsp
, name
);
1851 int smb_vfs_call_setxattr(struct vfs_handle_struct
*handle
, const char *path
,
1852 const char *name
, const void *value
, size_t size
,
1856 return handle
->fns
->setxattr(handle
, path
, name
, value
, size
, flags
);
1859 int smb_vfs_call_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
,
1860 const char *name
, const void *value
, size_t size
,
1863 VFS_FIND(lsetxattr
);
1864 return handle
->fns
->lsetxattr(handle
, path
, name
, value
, size
, flags
);
1867 int smb_vfs_call_fsetxattr(struct vfs_handle_struct
*handle
,
1868 struct files_struct
*fsp
, const char *name
,
1869 const void *value
, size_t size
, int flags
)
1871 VFS_FIND(fsetxattr
);
1872 return handle
->fns
->fsetxattr(handle
, fsp
, name
, value
, size
, flags
);
1875 int smb_vfs_call_aio_read(struct vfs_handle_struct
*handle
,
1876 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1879 return handle
->fns
->aio_read(handle
, fsp
, aiocb
);
1882 int smb_vfs_call_aio_write(struct vfs_handle_struct
*handle
,
1883 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1885 VFS_FIND(aio_write
);
1886 return handle
->fns
->aio_write(handle
, fsp
, aiocb
);
1889 ssize_t
smb_vfs_call_aio_return_fn(struct vfs_handle_struct
*handle
,
1890 struct files_struct
*fsp
,
1891 SMB_STRUCT_AIOCB
*aiocb
)
1893 VFS_FIND(aio_return_fn
);
1894 return handle
->fns
->aio_return_fn(handle
, fsp
, aiocb
);
1897 int smb_vfs_call_aio_cancel(struct vfs_handle_struct
*handle
,
1898 struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1900 VFS_FIND(aio_cancel
);
1901 return handle
->fns
->aio_cancel(handle
, fsp
, aiocb
);
1904 int smb_vfs_call_aio_error_fn(struct vfs_handle_struct
*handle
,
1905 struct files_struct
*fsp
,
1906 SMB_STRUCT_AIOCB
*aiocb
)
1908 VFS_FIND(aio_error_fn
);
1909 return handle
->fns
->aio_error_fn(handle
, fsp
, aiocb
);
1912 int smb_vfs_call_aio_fsync(struct vfs_handle_struct
*handle
,
1913 struct files_struct
*fsp
, int op
,
1914 SMB_STRUCT_AIOCB
*aiocb
)
1916 VFS_FIND(aio_fsync
);
1917 return handle
->fns
->aio_fsync(handle
, fsp
, op
, aiocb
);
1920 int smb_vfs_call_aio_suspend(struct vfs_handle_struct
*handle
,
1921 struct files_struct
*fsp
,
1922 const SMB_STRUCT_AIOCB
* const aiocb
[], int n
,
1923 const struct timespec
*timeout
)
1925 VFS_FIND(aio_suspend
);
1926 return handle
->fns
->aio_suspend(handle
, fsp
, aiocb
, n
, timeout
);
1929 bool smb_vfs_call_aio_force(struct vfs_handle_struct
*handle
,
1930 struct files_struct
*fsp
)
1932 VFS_FIND(aio_force
);
1933 return handle
->fns
->aio_force(handle
, fsp
);
1936 bool smb_vfs_call_is_offline(struct vfs_handle_struct
*handle
,
1937 const char *path
, SMB_STRUCT_STAT
*sbuf
)
1939 VFS_FIND(is_offline
);
1940 return handle
->fns
->is_offline(handle
, path
, sbuf
);
1943 int smb_vfs_call_set_offline(struct vfs_handle_struct
*handle
,
1946 VFS_FIND(set_offline
);
1947 return handle
->fns
->set_offline(handle
, path
);