2 Unix SMB/CIFS implementation.
3 Wrap disk only vfs functions to sidestep dodgy compilers.
4 Copyright (C) Tim Potter 1998
5 Copyright (C) Jeremy Allison 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #define DBGC_CLASS DBGC_VFS
26 /* Check for NULL pointer parameters in vfswrap_* functions */
28 /* We don't want to have NULL function pointers lying around. Someone
29 is sure to try and execute them. These stubs are used to prevent
32 static int vfswrap_connect(vfs_handle_struct
*handle
, const char *service
, const char *user
)
34 return 0; /* Return >= 0 for success */
37 static void vfswrap_disconnect(vfs_handle_struct
*handle
)
43 static uint64_t vfswrap_disk_free(vfs_handle_struct
*handle
, const char *path
, bool small_query
, uint64_t *bsize
,
44 uint64_t *dfree
, uint64_t *dsize
)
48 result
= sys_disk_free(handle
->conn
, path
, small_query
, bsize
, dfree
, dsize
);
52 static int vfswrap_get_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
54 #ifdef HAVE_SYS_QUOTAS
57 START_PROFILE(syscall_get_quota
);
58 result
= sys_get_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
59 END_PROFILE(syscall_get_quota
);
67 static int vfswrap_set_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
69 #ifdef HAVE_SYS_QUOTAS
72 START_PROFILE(syscall_set_quota
);
73 result
= sys_set_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
74 END_PROFILE(syscall_set_quota
);
82 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SHADOW_COPY_DATA
*shadow_copy_data
, bool labels
)
85 return -1; /* Not implemented. */
88 static int vfswrap_statvfs(struct vfs_handle_struct
*handle
, const char *path
, vfs_statvfs_struct
*statbuf
)
90 return sys_statvfs(path
, statbuf
);
93 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct
*handle
,
94 enum timestamp_set_resolution
*p_ts_res
)
96 connection_struct
*conn
= handle
->conn
;
97 uint32_t caps
= FILE_CASE_SENSITIVE_SEARCH
| FILE_CASE_PRESERVED_NAMES
;
98 struct smb_filename
*smb_fname_cpath
= NULL
;
102 #if defined(DARWINOS)
103 struct vfs_statvfs_struct statbuf
;
104 ZERO_STRUCT(statbuf
);
105 sys_statvfs(conn
->connectpath
, &statbuf
);
106 caps
= statbuf
.FsCapabilities
;
109 *p_ts_res
= TIMESTAMP_SET_SECONDS
;
111 /* Work out what timestamp resolution we can
112 * use when setting a timestamp. */
114 status
= create_synthetic_smb_fname(talloc_tos(),
119 if (!NT_STATUS_IS_OK(status
)) {
123 ret
= SMB_VFS_STAT(conn
, smb_fname_cpath
);
125 TALLOC_FREE(smb_fname_cpath
);
129 if (smb_fname_cpath
->st
.st_ex_mtime
.tv_nsec
||
130 smb_fname_cpath
->st
.st_ex_atime
.tv_nsec
||
131 smb_fname_cpath
->st
.st_ex_ctime
.tv_nsec
) {
132 /* If any of the normal UNIX directory timestamps
133 * have a non-zero tv_nsec component assume
134 * we might be able to set sub-second timestamps.
135 * See what filetime set primitives we have.
137 #if defined(HAVE_UTIMENSAT)
138 *p_ts_res
= TIMESTAMP_SET_NT_OR_BETTER
;
139 #elif defined(HAVE_UTIMES)
140 /* utimes allows msec timestamps to be set. */
141 *p_ts_res
= TIMESTAMP_SET_MSEC
;
142 #elif defined(HAVE_UTIME)
143 /* utime only allows sec timestamps to be set. */
144 *p_ts_res
= TIMESTAMP_SET_SECONDS
;
147 DEBUG(10,("vfswrap_fs_capabilities: timestamp "
149 "available on share %s, directory %s\n",
150 *p_ts_res
== TIMESTAMP_SET_MSEC
? "msec" : "sec",
151 lp_servicename(conn
->params
->service
),
152 conn
->connectpath
));
154 TALLOC_FREE(smb_fname_cpath
);
158 /* Directory operations */
160 static SMB_STRUCT_DIR
*vfswrap_opendir(vfs_handle_struct
*handle
, const char *fname
, const char *mask
, uint32 attr
)
162 SMB_STRUCT_DIR
*result
;
164 START_PROFILE(syscall_opendir
);
165 result
= sys_opendir(fname
);
166 END_PROFILE(syscall_opendir
);
170 static SMB_STRUCT_DIRENT
*vfswrap_readdir(vfs_handle_struct
*handle
,
171 SMB_STRUCT_DIR
*dirp
,
172 SMB_STRUCT_STAT
*sbuf
)
174 SMB_STRUCT_DIRENT
*result
;
176 START_PROFILE(syscall_readdir
);
177 result
= sys_readdir(dirp
);
178 /* Default Posix readdir() does not give us stat info.
179 * Set to invalid to indicate we didn't return this info. */
181 SET_STAT_INVALID(*sbuf
);
182 END_PROFILE(syscall_readdir
);
186 static void vfswrap_seekdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
, long offset
)
188 START_PROFILE(syscall_seekdir
);
189 sys_seekdir(dirp
, offset
);
190 END_PROFILE(syscall_seekdir
);
193 static long vfswrap_telldir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
196 START_PROFILE(syscall_telldir
);
197 result
= sys_telldir(dirp
);
198 END_PROFILE(syscall_telldir
);
202 static void vfswrap_rewinddir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
204 START_PROFILE(syscall_rewinddir
);
206 END_PROFILE(syscall_rewinddir
);
209 static int vfswrap_mkdir(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
212 bool has_dacl
= False
;
215 START_PROFILE(syscall_mkdir
);
217 if (lp_inherit_acls(SNUM(handle
->conn
))
218 && parent_dirname(talloc_tos(), path
, &parent
, NULL
)
219 && (has_dacl
= directory_has_default_acl(handle
->conn
, parent
)))
224 result
= mkdir(path
, mode
);
226 if (result
== 0 && !has_dacl
) {
228 * We need to do this as the default behavior of POSIX ACLs
229 * is to set the mask to be the requested group permission
230 * bits, not the group permission bits to be the requested
231 * group permission bits. This is not what we want, as it will
232 * mess up any inherited ACL bits that were set. JRA.
234 int saved_errno
= errno
; /* We may get ENOSYS */
235 if ((SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
) == -1) && (errno
== ENOSYS
))
239 END_PROFILE(syscall_mkdir
);
243 static int vfswrap_rmdir(vfs_handle_struct
*handle
, const char *path
)
247 START_PROFILE(syscall_rmdir
);
248 result
= rmdir(path
);
249 END_PROFILE(syscall_rmdir
);
253 static int vfswrap_closedir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
257 START_PROFILE(syscall_closedir
);
258 result
= sys_closedir(dirp
);
259 END_PROFILE(syscall_closedir
);
263 static void vfswrap_init_search_op(vfs_handle_struct
*handle
,
264 SMB_STRUCT_DIR
*dirp
)
266 /* Default behavior is a NOOP */
269 /* File operations */
271 static int vfswrap_open(vfs_handle_struct
*handle
,
272 struct smb_filename
*smb_fname
,
273 files_struct
*fsp
, int flags
, mode_t mode
)
277 START_PROFILE(syscall_open
);
279 if (smb_fname
->stream_name
) {
284 result
= sys_open(smb_fname
->base_name
, flags
, mode
);
286 END_PROFILE(syscall_open
);
290 static NTSTATUS
vfswrap_create_file(vfs_handle_struct
*handle
,
291 struct smb_request
*req
,
292 uint16_t root_dir_fid
,
293 struct smb_filename
*smb_fname
,
294 uint32_t access_mask
,
295 uint32_t share_access
,
296 uint32_t create_disposition
,
297 uint32_t create_options
,
298 uint32_t file_attributes
,
299 uint32_t oplock_request
,
300 uint64_t allocation_size
,
301 uint32_t private_flags
,
302 struct security_descriptor
*sd
,
303 struct ea_list
*ea_list
,
304 files_struct
**result
,
307 return create_file_default(handle
->conn
, req
, root_dir_fid
, smb_fname
,
308 access_mask
, share_access
,
309 create_disposition
, create_options
,
310 file_attributes
, oplock_request
,
311 allocation_size
, private_flags
,
316 static int vfswrap_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
320 START_PROFILE(syscall_close
);
321 result
= fd_close_posix(fsp
);
322 END_PROFILE(syscall_close
);
326 static ssize_t
vfswrap_read(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
, size_t n
)
330 START_PROFILE_BYTES(syscall_read
, n
);
331 result
= sys_read(fsp
->fh
->fd
, data
, n
);
332 END_PROFILE(syscall_read
);
336 static ssize_t
vfswrap_pread(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
,
337 size_t n
, SMB_OFF_T offset
)
341 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
342 START_PROFILE_BYTES(syscall_pread
, n
);
343 result
= sys_pread(fsp
->fh
->fd
, data
, n
, offset
);
344 END_PROFILE(syscall_pread
);
346 if (result
== -1 && errno
== ESPIPE
) {
347 /* Maintain the fiction that pipes can be seeked (sought?) on. */
348 result
= SMB_VFS_READ(fsp
, data
, n
);
352 #else /* HAVE_PREAD */
356 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
357 if (curr
== -1 && errno
== ESPIPE
) {
358 /* Maintain the fiction that pipes can be seeked (sought?) on. */
359 result
= SMB_VFS_READ(fsp
, data
, n
);
364 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
369 result
= SMB_VFS_READ(fsp
, data
, n
);
372 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
375 #endif /* HAVE_PREAD */
380 static ssize_t
vfswrap_write(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
, size_t n
)
384 START_PROFILE_BYTES(syscall_write
, n
);
385 result
= sys_write(fsp
->fh
->fd
, data
, n
);
386 END_PROFILE(syscall_write
);
390 static ssize_t
vfswrap_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
,
391 size_t n
, SMB_OFF_T offset
)
395 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
396 START_PROFILE_BYTES(syscall_pwrite
, n
);
397 result
= sys_pwrite(fsp
->fh
->fd
, data
, n
, offset
);
398 END_PROFILE(syscall_pwrite
);
400 if (result
== -1 && errno
== ESPIPE
) {
401 /* Maintain the fiction that pipes can be sought on. */
402 result
= SMB_VFS_WRITE(fsp
, data
, n
);
405 #else /* HAVE_PWRITE */
409 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
414 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
418 result
= SMB_VFS_WRITE(fsp
, data
, n
);
421 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
424 #endif /* HAVE_PWRITE */
429 static SMB_OFF_T
vfswrap_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T offset
, int whence
)
431 SMB_OFF_T result
= 0;
433 START_PROFILE(syscall_lseek
);
435 /* Cope with 'stat' file opens. */
436 if (fsp
->fh
->fd
!= -1)
437 result
= sys_lseek(fsp
->fh
->fd
, offset
, whence
);
440 * We want to maintain the fiction that we can seek
441 * on a fifo for file system purposes. This allows
442 * people to set up UNIX fifo's that feed data to Windows
446 if((result
== -1) && (errno
== ESPIPE
)) {
451 END_PROFILE(syscall_lseek
);
455 static ssize_t
vfswrap_sendfile(vfs_handle_struct
*handle
, int tofd
, files_struct
*fromfsp
, const DATA_BLOB
*hdr
,
456 SMB_OFF_T offset
, size_t n
)
460 START_PROFILE_BYTES(syscall_sendfile
, n
);
461 result
= sys_sendfile(tofd
, fromfsp
->fh
->fd
, hdr
, offset
, n
);
462 END_PROFILE(syscall_sendfile
);
466 static ssize_t
vfswrap_recvfile(vfs_handle_struct
*handle
,
474 START_PROFILE_BYTES(syscall_recvfile
, n
);
475 result
= sys_recvfile(fromfd
, tofsp
->fh
->fd
, offset
, n
);
476 END_PROFILE(syscall_recvfile
);
480 static int vfswrap_rename(vfs_handle_struct
*handle
,
481 const struct smb_filename
*smb_fname_src
,
482 const struct smb_filename
*smb_fname_dst
)
486 START_PROFILE(syscall_rename
);
488 if (smb_fname_src
->stream_name
|| smb_fname_dst
->stream_name
) {
493 result
= rename(smb_fname_src
->base_name
, smb_fname_dst
->base_name
);
496 END_PROFILE(syscall_rename
);
500 static int vfswrap_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
505 START_PROFILE(syscall_fsync
);
506 result
= fsync(fsp
->fh
->fd
);
507 END_PROFILE(syscall_fsync
);
514 static int vfswrap_stat(vfs_handle_struct
*handle
,
515 struct smb_filename
*smb_fname
)
519 START_PROFILE(syscall_stat
);
521 if (smb_fname
->stream_name
) {
526 result
= sys_stat(smb_fname
->base_name
, &smb_fname
->st
,
527 lp_fake_dir_create_times(SNUM(handle
->conn
)));
529 END_PROFILE(syscall_stat
);
533 static int vfswrap_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
537 START_PROFILE(syscall_fstat
);
538 result
= sys_fstat(fsp
->fh
->fd
,
539 sbuf
, lp_fake_dir_create_times(SNUM(handle
->conn
)));
540 END_PROFILE(syscall_fstat
);
544 static int vfswrap_lstat(vfs_handle_struct
*handle
,
545 struct smb_filename
*smb_fname
)
549 START_PROFILE(syscall_lstat
);
551 if (smb_fname
->stream_name
) {
556 result
= sys_lstat(smb_fname
->base_name
, &smb_fname
->st
,
557 lp_fake_dir_create_times(SNUM(handle
->conn
)));
559 END_PROFILE(syscall_lstat
);
563 static NTSTATUS
vfswrap_translate_name(struct vfs_handle_struct
*handle
,
565 enum vfs_translate_direction direction
,
569 return NT_STATUS_NONE_MAPPED
;
572 /********************************************************************
573 Given a stat buffer return the allocated size on disk, taking into
574 account sparse files.
575 ********************************************************************/
576 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct
*handle
,
577 struct files_struct
*fsp
,
578 const SMB_STRUCT_STAT
*sbuf
)
582 START_PROFILE(syscall_get_alloc_size
);
584 if(S_ISDIR(sbuf
->st_ex_mode
)) {
589 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
590 result
= (uint64_t)STAT_ST_BLOCKSIZE
* (uint64_t)sbuf
->st_ex_blocks
;
592 result
= get_file_size_stat(sbuf
);
595 if (fsp
&& fsp
->initial_allocation_size
)
596 result
= MAX(result
,fsp
->initial_allocation_size
);
598 result
= smb_roundup(handle
->conn
, result
);
601 END_PROFILE(syscall_get_alloc_size
);
605 static int vfswrap_unlink(vfs_handle_struct
*handle
,
606 const struct smb_filename
*smb_fname
)
610 START_PROFILE(syscall_unlink
);
612 if (smb_fname
->stream_name
) {
616 result
= unlink(smb_fname
->base_name
);
619 END_PROFILE(syscall_unlink
);
623 static int vfswrap_chmod(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
627 START_PROFILE(syscall_chmod
);
630 * We need to do this due to the fact that the default POSIX ACL
631 * chmod modifies the ACL *mask* for the group owner, not the
632 * group owner bits directly. JRA.
637 int saved_errno
= errno
; /* We might get ENOSYS */
638 if ((result
= SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
)) == 0) {
639 END_PROFILE(syscall_chmod
);
642 /* Error - return the old errno. */
646 result
= chmod(path
, mode
);
647 END_PROFILE(syscall_chmod
);
651 static int vfswrap_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
655 START_PROFILE(syscall_fchmod
);
658 * We need to do this due to the fact that the default POSIX ACL
659 * chmod modifies the ACL *mask* for the group owner, not the
660 * group owner bits directly. JRA.
664 int saved_errno
= errno
; /* We might get ENOSYS */
665 if ((result
= SMB_VFS_FCHMOD_ACL(fsp
, mode
)) == 0) {
666 END_PROFILE(syscall_fchmod
);
669 /* Error - return the old errno. */
673 #if defined(HAVE_FCHMOD)
674 result
= fchmod(fsp
->fh
->fd
, mode
);
680 END_PROFILE(syscall_fchmod
);
684 static int vfswrap_chown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
688 START_PROFILE(syscall_chown
);
689 result
= chown(path
, uid
, gid
);
690 END_PROFILE(syscall_chown
);
694 static int vfswrap_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
, uid_t uid
, gid_t gid
)
699 START_PROFILE(syscall_fchown
);
700 result
= fchown(fsp
->fh
->fd
, uid
, gid
);
701 END_PROFILE(syscall_fchown
);
709 static int vfswrap_lchown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
713 START_PROFILE(syscall_lchown
);
714 result
= lchown(path
, uid
, gid
);
715 END_PROFILE(syscall_lchown
);
719 static int vfswrap_chdir(vfs_handle_struct
*handle
, const char *path
)
723 START_PROFILE(syscall_chdir
);
724 result
= chdir(path
);
725 END_PROFILE(syscall_chdir
);
729 static char *vfswrap_getwd(vfs_handle_struct
*handle
, char *path
)
733 START_PROFILE(syscall_getwd
);
734 result
= sys_getwd(path
);
735 END_PROFILE(syscall_getwd
);
739 /*********************************************************************
740 nsec timestamp resolution call. Convert down to whatever the underlying
742 **********************************************************************/
744 static int vfswrap_ntimes(vfs_handle_struct
*handle
,
745 const struct smb_filename
*smb_fname
,
746 struct smb_file_time
*ft
)
750 START_PROFILE(syscall_ntimes
);
752 if (smb_fname
->stream_name
) {
757 if (null_timespec(ft
->atime
)) {
758 ft
->atime
= smb_fname
->st
.st_ex_atime
;
761 if (null_timespec(ft
->mtime
)) {
762 ft
->mtime
= smb_fname
->st
.st_ex_mtime
;
765 if (!null_timespec(ft
->create_time
)) {
766 set_create_timespec_ea(handle
->conn
,
771 if ((timespec_compare(&ft
->atime
,
772 &smb_fname
->st
.st_ex_atime
) == 0) &&
773 (timespec_compare(&ft
->mtime
,
774 &smb_fname
->st
.st_ex_mtime
) == 0)) {
778 #if defined(HAVE_UTIMENSAT)
780 struct timespec ts
[2];
783 result
= utimensat(AT_FDCWD
, smb_fname
->base_name
, ts
, 0);
785 result
= utimensat(AT_FDCWD
, smb_fname
->base_name
, NULL
, 0);
787 #elif defined(HAVE_UTIMES)
789 struct timeval tv
[2];
790 tv
[0] = convert_timespec_to_timeval(ft
->atime
);
791 tv
[1] = convert_timespec_to_timeval(ft
->mtime
);
792 result
= utimes(smb_fname
->base_name
, tv
);
794 result
= utimes(smb_fname
->base_name
, NULL
);
796 #elif defined(HAVE_UTIME)
798 struct utimbuf times
;
799 times
.actime
= convert_timespec_to_time_t(ft
->atime
);
800 times
.modtime
= convert_timespec_to_time_t(ft
->mtime
);
801 result
= utime(smb_fname
->base_name
, ×
);
803 result
= utime(smb_fname
->base_name
, NULL
);
811 END_PROFILE(syscall_ntimes
);
815 /*********************************************************************
816 A version of ftruncate that will write the space on disk if strict
818 **********************************************************************/
820 static int strict_allocate_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
823 SMB_OFF_T currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
824 unsigned char zero_space
[4096];
825 SMB_OFF_T space_to_write
;
826 uint64_t space_avail
;
827 uint64_t bsize
,dfree
,dsize
;
833 if (SMB_VFS_FSTAT(fsp
, &st
) == -1)
837 if (S_ISFIFO(st
.st_ex_mode
))
841 if (st
.st_ex_size
== len
)
844 /* Shrink - just ftruncate. */
845 if (st
.st_ex_size
> len
)
846 return sys_ftruncate(fsp
->fh
->fd
, len
);
848 space_to_write
= len
- st
.st_ex_size
;
850 /* for allocation try posix_fallocate first. This can fail on some
851 platforms e.g. when the filesystem doesn't support it and no
852 emulation is being done by the libc (like on AIX with JFS1). In that
853 case we do our own emulation. posix_fallocate implementations can
854 return ENOTSUP or EINVAL in cases like that. */
855 ret
= sys_posix_fallocate(fsp
->fh
->fd
, st
.st_ex_size
, space_to_write
);
863 DEBUG(10,("strict_allocate_ftruncate: sys_posix_fallocate failed with "
864 "error %d. Falling back to slow manual allocation\n", ret
));
866 /* available disk space is enough or not? */
867 space_avail
= get_dfree_info(fsp
->conn
,
868 fsp
->fsp_name
->base_name
, false,
869 &bsize
,&dfree
,&dsize
);
870 /* space_avail is 1k blocks */
871 if (space_avail
== (uint64_t)-1 ||
872 ((uint64_t)space_to_write
/1024 > space_avail
) ) {
877 /* Write out the real space on disk. */
878 if (SMB_VFS_LSEEK(fsp
, st
.st_ex_size
, SEEK_SET
) != st
.st_ex_size
)
881 memset(zero_space
, '\0', sizeof(zero_space
));
882 while ( space_to_write
> 0) {
884 SMB_OFF_T current_len_to_write
= MIN(sizeof(zero_space
),space_to_write
);
886 retlen
= SMB_VFS_WRITE(fsp
,(char *)zero_space
,current_len_to_write
);
890 space_to_write
-= retlen
;
893 /* Seek to where we were */
894 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
900 static int vfswrap_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
907 START_PROFILE(syscall_ftruncate
);
909 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
910 result
= strict_allocate_ftruncate(handle
, fsp
, len
);
911 END_PROFILE(syscall_ftruncate
);
915 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
916 sys_ftruncate if the system supports it. Then I discovered that
917 you can have some filesystems that support ftruncate
918 expansion and some that don't! On Linux fat can't do
919 ftruncate extend but ext2 can. */
921 result
= sys_ftruncate(fsp
->fh
->fd
, len
);
925 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
926 extend a file with ftruncate. Provide alternate implementation
928 currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
933 /* Do an fstat to see if the file is longer than the requested
934 size in which case the ftruncate above should have
935 succeeded or shorter, in which case seek to len - 1 and
936 write 1 byte of zero */
937 if (SMB_VFS_FSTAT(fsp
, &st
) == -1) {
942 if (S_ISFIFO(st
.st_ex_mode
)) {
948 if (st
.st_ex_size
== len
) {
953 if (st
.st_ex_size
> len
) {
954 /* the sys_ftruncate should have worked */
958 if (SMB_VFS_LSEEK(fsp
, len
-1, SEEK_SET
) != len
-1)
961 if (SMB_VFS_WRITE(fsp
, &c
, 1)!=1)
964 /* Seek to where we were */
965 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
971 END_PROFILE(syscall_ftruncate
);
975 static bool vfswrap_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
979 START_PROFILE(syscall_fcntl_lock
);
980 result
= fcntl_lock(fsp
->fh
->fd
, op
, offset
, count
, type
);
981 END_PROFILE(syscall_fcntl_lock
);
985 static int vfswrap_kernel_flock(vfs_handle_struct
*handle
, files_struct
*fsp
,
986 uint32 share_mode
, uint32 access_mask
)
988 START_PROFILE(syscall_kernel_flock
);
989 kernel_flock(fsp
->fh
->fd
, share_mode
, access_mask
);
990 END_PROFILE(syscall_kernel_flock
);
994 static bool vfswrap_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
998 START_PROFILE(syscall_fcntl_getlock
);
999 result
= fcntl_getlock(fsp
->fh
->fd
, poffset
, pcount
, ptype
, ppid
);
1000 END_PROFILE(syscall_fcntl_getlock
);
1004 static int vfswrap_linux_setlease(vfs_handle_struct
*handle
, files_struct
*fsp
,
1009 START_PROFILE(syscall_linux_setlease
);
1011 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
1012 /* first set the signal handler */
1013 if(linux_set_lease_sighandler(fsp
->fh
->fd
) == -1) {
1017 result
= linux_setlease(fsp
->fh
->fd
, leasetype
);
1021 END_PROFILE(syscall_linux_setlease
);
1025 static int vfswrap_symlink(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
1029 START_PROFILE(syscall_symlink
);
1030 result
= symlink(oldpath
, newpath
);
1031 END_PROFILE(syscall_symlink
);
1035 static int vfswrap_readlink(vfs_handle_struct
*handle
, const char *path
, char *buf
, size_t bufsiz
)
1039 START_PROFILE(syscall_readlink
);
1040 result
= readlink(path
, buf
, bufsiz
);
1041 END_PROFILE(syscall_readlink
);
1045 static int vfswrap_link(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
1049 START_PROFILE(syscall_link
);
1050 result
= link(oldpath
, newpath
);
1051 END_PROFILE(syscall_link
);
1055 static int vfswrap_mknod(vfs_handle_struct
*handle
, const char *pathname
, mode_t mode
, SMB_DEV_T dev
)
1059 START_PROFILE(syscall_mknod
);
1060 result
= sys_mknod(pathname
, mode
, dev
);
1061 END_PROFILE(syscall_mknod
);
1065 static char *vfswrap_realpath(vfs_handle_struct
*handle
, const char *path
, char *resolved_path
)
1069 START_PROFILE(syscall_realpath
);
1070 result
= realpath(path
, resolved_path
);
1071 END_PROFILE(syscall_realpath
);
1075 static NTSTATUS
vfswrap_notify_watch(vfs_handle_struct
*vfs_handle
,
1076 struct sys_notify_context
*ctx
,
1077 struct notify_entry
*e
,
1078 void (*callback
)(struct sys_notify_context
*ctx
,
1080 struct notify_event
*ev
),
1081 void *private_data
, void *handle
)
1084 * So far inotify is the only supported default notify mechanism. If
1085 * another platform like the the BSD's or a proprietary Unix comes
1086 * along and wants another default, we can play the same trick we
1087 * played with Posix ACLs.
1089 * Until that is the case, hard-code inotify here.
1092 if (lp_kernel_change_notify(ctx
->conn
->params
)) {
1093 return inotify_watch(ctx
, e
, callback
, private_data
, handle
);
1097 * Do nothing, leave everything to notify_internal.c
1099 return NT_STATUS_OK
;
1102 static int vfswrap_chflags(vfs_handle_struct
*handle
, const char *path
,
1106 return chflags(path
, flags
);
1113 static struct file_id
vfswrap_file_id_create(struct vfs_handle_struct
*handle
,
1114 const SMB_STRUCT_STAT
*sbuf
)
1118 /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1122 key
.devid
= sbuf
->st_ex_dev
;
1123 key
.inode
= sbuf
->st_ex_ino
;
1124 /* key.extid is unused by default. */
1129 static NTSTATUS
vfswrap_streaminfo(vfs_handle_struct
*handle
,
1130 struct files_struct
*fsp
,
1132 TALLOC_CTX
*mem_ctx
,
1133 unsigned int *pnum_streams
,
1134 struct stream_struct
**pstreams
)
1136 SMB_STRUCT_STAT sbuf
;
1137 unsigned int num_streams
= 0;
1138 struct stream_struct
*streams
= NULL
;
1141 if ((fsp
!= NULL
) && (fsp
->is_directory
)) {
1143 * No default streams on directories
1148 if ((fsp
!= NULL
) && (fsp
->fh
->fd
!= -1)) {
1149 ret
= SMB_VFS_FSTAT(fsp
, &sbuf
);
1152 struct smb_filename smb_fname
;
1154 ZERO_STRUCT(smb_fname
);
1155 smb_fname
.base_name
= discard_const_p(char, fname
);
1157 if (lp_posix_pathnames()) {
1158 ret
= SMB_VFS_LSTAT(handle
->conn
, &smb_fname
);
1160 ret
= SMB_VFS_STAT(handle
->conn
, &smb_fname
);
1162 sbuf
= smb_fname
.st
;
1166 return map_nt_error_from_unix(errno
);
1169 if (S_ISDIR(sbuf
.st_ex_mode
)) {
1173 streams
= talloc(mem_ctx
, struct stream_struct
);
1175 if (streams
== NULL
) {
1176 return NT_STATUS_NO_MEMORY
;
1179 streams
->size
= sbuf
.st_ex_size
;
1180 streams
->alloc_size
= SMB_VFS_GET_ALLOC_SIZE(handle
->conn
, fsp
, &sbuf
);
1182 streams
->name
= talloc_strdup(streams
, "::$DATA");
1183 if (streams
->name
== NULL
) {
1184 TALLOC_FREE(streams
);
1185 return NT_STATUS_NO_MEMORY
;
1190 *pnum_streams
= num_streams
;
1191 *pstreams
= streams
;
1192 return NT_STATUS_OK
;
1195 static int vfswrap_get_real_filename(struct vfs_handle_struct
*handle
,
1198 TALLOC_CTX
*mem_ctx
,
1202 * Don't fall back to get_real_filename so callers can differentiate
1203 * between a full directory scan and an actual case-insensitive stat.
1209 static const char *vfswrap_connectpath(struct vfs_handle_struct
*handle
,
1212 return handle
->conn
->connectpath
;
1215 static NTSTATUS
vfswrap_brl_lock_windows(struct vfs_handle_struct
*handle
,
1216 struct byte_range_lock
*br_lck
,
1217 struct lock_struct
*plock
,
1219 struct blocking_lock_record
*blr
)
1221 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1223 /* Note: blr is not used in the default implementation. */
1224 return brl_lock_windows_default(br_lck
, plock
, blocking_lock
);
1227 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1228 struct messaging_context
*msg_ctx
,
1229 struct byte_range_lock
*br_lck
,
1230 const struct lock_struct
*plock
)
1232 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1234 return brl_unlock_windows_default(msg_ctx
, br_lck
, plock
);
1237 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1238 struct byte_range_lock
*br_lck
,
1239 struct lock_struct
*plock
,
1240 struct blocking_lock_record
*blr
)
1242 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1244 /* Note: blr is not used in the default implementation. */
1245 return brl_lock_cancel_default(br_lck
, plock
);
1248 static bool vfswrap_strict_lock(struct vfs_handle_struct
*handle
,
1250 struct lock_struct
*plock
)
1252 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1253 plock
->lock_type
== WRITE_LOCK
);
1255 return strict_lock_default(fsp
, plock
);
1258 static void vfswrap_strict_unlock(struct vfs_handle_struct
*handle
,
1260 struct lock_struct
*plock
)
1262 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1263 plock
->lock_type
== WRITE_LOCK
);
1265 strict_unlock_default(fsp
, plock
);
1268 /* NT ACL operations. */
1270 static NTSTATUS
vfswrap_fget_nt_acl(vfs_handle_struct
*handle
,
1272 uint32 security_info
, SEC_DESC
**ppdesc
)
1276 START_PROFILE(fget_nt_acl
);
1277 result
= posix_fget_nt_acl(fsp
, security_info
, ppdesc
);
1278 END_PROFILE(fget_nt_acl
);
1282 static NTSTATUS
vfswrap_get_nt_acl(vfs_handle_struct
*handle
,
1284 uint32 security_info
, SEC_DESC
**ppdesc
)
1288 START_PROFILE(get_nt_acl
);
1289 result
= posix_get_nt_acl(handle
->conn
, name
, security_info
, ppdesc
);
1290 END_PROFILE(get_nt_acl
);
1294 static NTSTATUS
vfswrap_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, uint32 security_info_sent
, const SEC_DESC
*psd
)
1298 START_PROFILE(fset_nt_acl
);
1299 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
1300 END_PROFILE(fset_nt_acl
);
1304 static int vfswrap_chmod_acl(vfs_handle_struct
*handle
, const char *name
, mode_t mode
)
1312 START_PROFILE(chmod_acl
);
1313 result
= chmod_acl(handle
->conn
, name
, mode
);
1314 END_PROFILE(chmod_acl
);
1319 static int vfswrap_fchmod_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
1327 START_PROFILE(fchmod_acl
);
1328 result
= fchmod_acl(fsp
, mode
);
1329 END_PROFILE(fchmod_acl
);
1334 static int vfswrap_sys_acl_get_entry(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, int entry_id
, SMB_ACL_ENTRY_T
*entry_p
)
1336 return sys_acl_get_entry(theacl
, entry_id
, entry_p
);
1339 static int vfswrap_sys_acl_get_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_TAG_T
*tag_type_p
)
1341 return sys_acl_get_tag_type(entry_d
, tag_type_p
);
1344 static int vfswrap_sys_acl_get_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_PERMSET_T
*permset_p
)
1346 return sys_acl_get_permset(entry_d
, permset_p
);
1349 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
)
1351 return sys_acl_get_qualifier(entry_d
);
1354 static SMB_ACL_T
vfswrap_sys_acl_get_file(vfs_handle_struct
*handle
, const char *path_p
, SMB_ACL_TYPE_T type
)
1356 return sys_acl_get_file(handle
, path_p
, type
);
1359 static SMB_ACL_T
vfswrap_sys_acl_get_fd(vfs_handle_struct
*handle
, files_struct
*fsp
)
1361 return sys_acl_get_fd(handle
, fsp
);
1364 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
)
1366 return sys_acl_clear_perms(permset
);
1369 static int vfswrap_sys_acl_add_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1371 return sys_acl_add_perm(permset
, perm
);
1374 static char * vfswrap_sys_acl_to_text(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, ssize_t
*plen
)
1376 return sys_acl_to_text(theacl
, plen
);
1379 static SMB_ACL_T
vfswrap_sys_acl_init(vfs_handle_struct
*handle
, int count
)
1381 return sys_acl_init(count
);
1384 static int vfswrap_sys_acl_create_entry(vfs_handle_struct
*handle
, SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1386 return sys_acl_create_entry(pacl
, pentry
);
1389 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_TAG_T tagtype
)
1391 return sys_acl_set_tag_type(entry
, tagtype
);
1394 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, void *qual
)
1396 return sys_acl_set_qualifier(entry
, qual
);
1399 static int vfswrap_sys_acl_set_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_PERMSET_T permset
)
1401 return sys_acl_set_permset(entry
, permset
);
1404 static int vfswrap_sys_acl_valid(vfs_handle_struct
*handle
, SMB_ACL_T theacl
)
1406 return sys_acl_valid(theacl
);
1409 static int vfswrap_sys_acl_set_file(vfs_handle_struct
*handle
, const char *name
, SMB_ACL_TYPE_T acltype
, SMB_ACL_T theacl
)
1411 return sys_acl_set_file(handle
, name
, acltype
, theacl
);
1414 static int vfswrap_sys_acl_set_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_ACL_T theacl
)
1416 return sys_acl_set_fd(handle
, fsp
, theacl
);
1419 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct
*handle
, const char *path
)
1421 return sys_acl_delete_def_file(handle
, path
);
1424 static int vfswrap_sys_acl_get_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1426 return sys_acl_get_perm(permset
, perm
);
1429 static int vfswrap_sys_acl_free_text(vfs_handle_struct
*handle
, char *text
)
1431 return sys_acl_free_text(text
);
1434 static int vfswrap_sys_acl_free_acl(vfs_handle_struct
*handle
, SMB_ACL_T posix_acl
)
1436 return sys_acl_free_acl(posix_acl
);
1439 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct
*handle
, void *qualifier
, SMB_ACL_TAG_T tagtype
)
1441 return sys_acl_free_qualifier(qualifier
, tagtype
);
1444 /****************************************************************
1445 Extended attribute operations.
1446 *****************************************************************/
1448 static ssize_t
vfswrap_getxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1450 return sys_getxattr(path
, name
, value
, size
);
1453 static ssize_t
vfswrap_lgetxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1455 return sys_lgetxattr(path
, name
, value
, size
);
1458 static ssize_t
vfswrap_fgetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, void *value
, size_t size
)
1460 return sys_fgetxattr(fsp
->fh
->fd
, name
, value
, size
);
1463 static ssize_t
vfswrap_listxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1465 return sys_listxattr(path
, list
, size
);
1468 ssize_t
vfswrap_llistxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1470 return sys_llistxattr(path
, list
, size
);
1473 ssize_t
vfswrap_flistxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, char *list
, size_t size
)
1475 return sys_flistxattr(fsp
->fh
->fd
, list
, size
);
1478 static int vfswrap_removexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1480 return sys_removexattr(path
, name
);
1483 static int vfswrap_lremovexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1485 return sys_lremovexattr(path
, name
);
1488 static int vfswrap_fremovexattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
)
1490 return sys_fremovexattr(fsp
->fh
->fd
, name
);
1493 static int vfswrap_setxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1495 return sys_setxattr(path
, name
, value
, size
, flags
);
1498 static int vfswrap_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1500 return sys_lsetxattr(path
, name
, value
, size
, flags
);
1503 static int vfswrap_fsetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, const void *value
, size_t size
, int flags
)
1505 return sys_fsetxattr(fsp
->fh
->fd
, name
, value
, size
, flags
);
1508 static int vfswrap_aio_read(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1512 * aio_read must be done as root, because in the glibc aio
1513 * implementation the helper thread needs to be able to send a signal
1514 * to the main thread, even when it has done a seteuid() to a
1518 ret
= sys_aio_read(aiocb
);
1523 static int vfswrap_aio_write(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1527 * aio_write must be done as root, because in the glibc aio
1528 * implementation the helper thread needs to be able to send a signal
1529 * to the main thread, even when it has done a seteuid() to a
1533 ret
= sys_aio_write(aiocb
);
1538 static ssize_t
vfswrap_aio_return(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1540 return sys_aio_return(aiocb
);
1543 static int vfswrap_aio_cancel(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1545 return sys_aio_cancel(fsp
->fh
->fd
, aiocb
);
1548 static int vfswrap_aio_error(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1550 return sys_aio_error(aiocb
);
1553 static int vfswrap_aio_fsync(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int op
, SMB_STRUCT_AIOCB
*aiocb
)
1555 return sys_aio_fsync(op
, aiocb
);
1558 static int vfswrap_aio_suspend(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const SMB_STRUCT_AIOCB
* const aiocb
[], int n
, const struct timespec
*timeout
)
1560 return sys_aio_suspend(aiocb
, n
, timeout
);
1563 static bool vfswrap_aio_force(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
)
1568 static bool vfswrap_is_offline(struct vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
1570 if (ISDOT(path
) || ISDOTDOT(path
)) {
1574 if (!lp_dmapi_support(SNUM(handle
->conn
)) || !dmapi_have_session()) {
1575 #if defined(ENOTSUP)
1581 return (dmapi_file_flags(path
) & FILE_ATTRIBUTE_OFFLINE
) != 0;
1584 static int vfswrap_set_offline(struct vfs_handle_struct
*handle
, const char *path
)
1586 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1587 #if defined(ENOTSUP)
1593 static struct vfs_fn_pointers vfs_default_fns
= {
1594 /* Disk operations */
1596 .connect_fn
= vfswrap_connect
,
1597 .disconnect
= vfswrap_disconnect
,
1598 .disk_free
= vfswrap_disk_free
,
1599 .get_quota
= vfswrap_get_quota
,
1600 .set_quota
= vfswrap_set_quota
,
1601 .get_shadow_copy_data
= vfswrap_get_shadow_copy_data
,
1602 .statvfs
= vfswrap_statvfs
,
1603 .fs_capabilities
= vfswrap_fs_capabilities
,
1605 /* Directory operations */
1607 .opendir
= vfswrap_opendir
,
1608 .readdir
= vfswrap_readdir
,
1609 .seekdir
= vfswrap_seekdir
,
1610 .telldir
= vfswrap_telldir
,
1611 .rewind_dir
= vfswrap_rewinddir
,
1612 .mkdir
= vfswrap_mkdir
,
1613 .rmdir
= vfswrap_rmdir
,
1614 .closedir
= vfswrap_closedir
,
1615 .init_search_op
= vfswrap_init_search_op
,
1617 /* File operations */
1619 .open
= vfswrap_open
,
1620 .create_file
= vfswrap_create_file
,
1621 .close_fn
= vfswrap_close
,
1622 .vfs_read
= vfswrap_read
,
1623 .pread
= vfswrap_pread
,
1624 .write
= vfswrap_write
,
1625 .pwrite
= vfswrap_pwrite
,
1626 .lseek
= vfswrap_lseek
,
1627 .sendfile
= vfswrap_sendfile
,
1628 .recvfile
= vfswrap_recvfile
,
1629 .rename
= vfswrap_rename
,
1630 .fsync
= vfswrap_fsync
,
1631 .stat
= vfswrap_stat
,
1632 .fstat
= vfswrap_fstat
,
1633 .lstat
= vfswrap_lstat
,
1634 .get_alloc_size
= vfswrap_get_alloc_size
,
1635 .unlink
= vfswrap_unlink
,
1636 .chmod
= vfswrap_chmod
,
1637 .fchmod
= vfswrap_fchmod
,
1638 .chown
= vfswrap_chown
,
1639 .fchown
= vfswrap_fchown
,
1640 .lchown
= vfswrap_lchown
,
1641 .chdir
= vfswrap_chdir
,
1642 .getwd
= vfswrap_getwd
,
1643 .ntimes
= vfswrap_ntimes
,
1644 .ftruncate
= vfswrap_ftruncate
,
1645 .lock
= vfswrap_lock
,
1646 .kernel_flock
= vfswrap_kernel_flock
,
1647 .linux_setlease
= vfswrap_linux_setlease
,
1648 .getlock
= vfswrap_getlock
,
1649 .symlink
= vfswrap_symlink
,
1650 .vfs_readlink
= vfswrap_readlink
,
1651 .link
= vfswrap_link
,
1652 .mknod
= vfswrap_mknod
,
1653 .realpath
= vfswrap_realpath
,
1654 .notify_watch
= vfswrap_notify_watch
,
1655 .chflags
= vfswrap_chflags
,
1656 .file_id_create
= vfswrap_file_id_create
,
1657 .streaminfo
= vfswrap_streaminfo
,
1658 .get_real_filename
= vfswrap_get_real_filename
,
1659 .connectpath
= vfswrap_connectpath
,
1660 .brl_lock_windows
= vfswrap_brl_lock_windows
,
1661 .brl_unlock_windows
= vfswrap_brl_unlock_windows
,
1662 .brl_cancel_windows
= vfswrap_brl_cancel_windows
,
1663 .strict_lock
= vfswrap_strict_lock
,
1664 .strict_unlock
= vfswrap_strict_unlock
,
1665 .translate_name
= vfswrap_translate_name
,
1667 /* NT ACL operations. */
1669 .fget_nt_acl
= vfswrap_fget_nt_acl
,
1670 .get_nt_acl
= vfswrap_get_nt_acl
,
1671 .fset_nt_acl
= vfswrap_fset_nt_acl
,
1673 /* POSIX ACL operations. */
1675 .chmod_acl
= vfswrap_chmod_acl
,
1676 .fchmod_acl
= vfswrap_fchmod_acl
,
1678 .sys_acl_get_entry
= vfswrap_sys_acl_get_entry
,
1679 .sys_acl_get_tag_type
= vfswrap_sys_acl_get_tag_type
,
1680 .sys_acl_get_permset
= vfswrap_sys_acl_get_permset
,
1681 .sys_acl_get_qualifier
= vfswrap_sys_acl_get_qualifier
,
1682 .sys_acl_get_file
= vfswrap_sys_acl_get_file
,
1683 .sys_acl_get_fd
= vfswrap_sys_acl_get_fd
,
1684 .sys_acl_clear_perms
= vfswrap_sys_acl_clear_perms
,
1685 .sys_acl_add_perm
= vfswrap_sys_acl_add_perm
,
1686 .sys_acl_to_text
= vfswrap_sys_acl_to_text
,
1687 .sys_acl_init
= vfswrap_sys_acl_init
,
1688 .sys_acl_create_entry
= vfswrap_sys_acl_create_entry
,
1689 .sys_acl_set_tag_type
= vfswrap_sys_acl_set_tag_type
,
1690 .sys_acl_set_qualifier
= vfswrap_sys_acl_set_qualifier
,
1691 .sys_acl_set_permset
= vfswrap_sys_acl_set_permset
,
1692 .sys_acl_valid
= vfswrap_sys_acl_valid
,
1693 .sys_acl_set_file
= vfswrap_sys_acl_set_file
,
1694 .sys_acl_set_fd
= vfswrap_sys_acl_set_fd
,
1695 .sys_acl_delete_def_file
= vfswrap_sys_acl_delete_def_file
,
1696 .sys_acl_get_perm
= vfswrap_sys_acl_get_perm
,
1697 .sys_acl_free_text
= vfswrap_sys_acl_free_text
,
1698 .sys_acl_free_acl
= vfswrap_sys_acl_free_acl
,
1699 .sys_acl_free_qualifier
= vfswrap_sys_acl_free_qualifier
,
1701 /* EA operations. */
1702 .getxattr
= vfswrap_getxattr
,
1703 .lgetxattr
= vfswrap_lgetxattr
,
1704 .fgetxattr
= vfswrap_fgetxattr
,
1705 .listxattr
= vfswrap_listxattr
,
1706 .llistxattr
= vfswrap_llistxattr
,
1707 .flistxattr
= vfswrap_flistxattr
,
1708 .removexattr
= vfswrap_removexattr
,
1709 .lremovexattr
= vfswrap_lremovexattr
,
1710 .fremovexattr
= vfswrap_fremovexattr
,
1711 .setxattr
= vfswrap_setxattr
,
1712 .lsetxattr
= vfswrap_lsetxattr
,
1713 .fsetxattr
= vfswrap_fsetxattr
,
1715 /* aio operations */
1716 .aio_read
= vfswrap_aio_read
,
1717 .aio_write
= vfswrap_aio_write
,
1718 .aio_return_fn
= vfswrap_aio_return
,
1719 .aio_cancel
= vfswrap_aio_cancel
,
1720 .aio_error_fn
= vfswrap_aio_error
,
1721 .aio_fsync
= vfswrap_aio_fsync
,
1722 .aio_suspend
= vfswrap_aio_suspend
,
1723 .aio_force
= vfswrap_aio_force
,
1725 /* offline operations */
1726 .is_offline
= vfswrap_is_offline
,
1727 .set_offline
= vfswrap_set_offline
1730 NTSTATUS
vfs_default_init(void);
1731 NTSTATUS
vfs_default_init(void)
1733 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
,
1734 DEFAULT_VFS_MODULE_NAME
, &vfs_default_fns
);