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 SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle, const char *path, bool small_query, SMB_BIG_UINT *bsize,
44 SMB_BIG_UINT *dfree, SMB_BIG_UINT *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)
96 struct vfs_statvfs_struct statbuf;
98 sys_statvfs(handle->conn->connectpath, &statbuf);
99 return statbuf.FsCapabilities;
101 return FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
104 /* Directory operations */
106 static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attr)
108 SMB_STRUCT_DIR *result;
110 START_PROFILE(syscall_opendir);
111 result = sys_opendir(fname);
112 END_PROFILE(syscall_opendir);
116 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
118 SMB_STRUCT_DIRENT *result;
120 START_PROFILE(syscall_readdir);
121 result = sys_readdir(dirp);
122 END_PROFILE(syscall_readdir);
126 static void vfswrap_seekdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset)
128 START_PROFILE(syscall_seekdir);
129 sys_seekdir(dirp, offset);
130 END_PROFILE(syscall_seekdir);
133 static long vfswrap_telldir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
136 START_PROFILE(syscall_telldir);
137 result = sys_telldir(dirp);
138 END_PROFILE(syscall_telldir);
142 static void vfswrap_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
144 START_PROFILE(syscall_rewinddir);
146 END_PROFILE(syscall_rewinddir);
149 static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
152 bool has_dacl = False;
154 START_PROFILE(syscall_mkdir);
156 if (lp_inherit_acls(SNUM(handle->conn)) && (has_dacl = directory_has_default_acl(handle->conn, parent_dirname(path))))
159 result = mkdir(path, mode);
161 if (result == 0 && !has_dacl) {
163 * We need to do this as the default behavior of POSIX ACLs
164 * is to set the mask to be the requested group permission
165 * bits, not the group permission bits to be the requested
166 * group permission bits. This is not what we want, as it will
167 * mess up any inherited ACL bits that were set. JRA.
169 int saved_errno = errno; /* We may get ENOSYS */
170 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
174 END_PROFILE(syscall_mkdir);
178 static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
182 START_PROFILE(syscall_rmdir);
183 result = rmdir(path);
184 END_PROFILE(syscall_rmdir);
188 static int vfswrap_closedir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
192 START_PROFILE(syscall_closedir);
193 result = sys_closedir(dirp);
194 END_PROFILE(syscall_closedir);
198 /* File operations */
200 static int vfswrap_open(vfs_handle_struct *handle, const char *fname,
201 files_struct *fsp, int flags, mode_t mode)
205 START_PROFILE(syscall_open);
206 result = sys_open(fname, flags, mode);
207 END_PROFILE(syscall_open);
211 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
215 START_PROFILE(syscall_close);
218 END_PROFILE(syscall_close);
222 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
226 START_PROFILE_BYTES(syscall_read, n);
227 result = sys_read(fsp->fh->fd, data, n);
228 END_PROFILE(syscall_read);
232 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
233 size_t n, SMB_OFF_T offset)
237 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
238 START_PROFILE_BYTES(syscall_pread, n);
239 result = sys_pread(fsp->fh->fd, data, n, offset);
240 END_PROFILE(syscall_pread);
242 if (result == -1 && errno == ESPIPE) {
243 /* Maintain the fiction that pipes can be seeked (sought?) on. */
244 result = SMB_VFS_READ(fsp, data, n);
248 #else /* HAVE_PREAD */
252 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
253 if (curr == -1 && errno == ESPIPE) {
254 /* Maintain the fiction that pipes can be seeked (sought?) on. */
255 result = SMB_VFS_READ(fsp, data, n);
260 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
265 result = SMB_VFS_READ(fsp, data, n);
268 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
271 #endif /* HAVE_PREAD */
276 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
280 START_PROFILE_BYTES(syscall_write, n);
281 result = sys_write(fsp->fh->fd, data, n);
282 END_PROFILE(syscall_write);
286 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
287 size_t n, SMB_OFF_T offset)
291 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
292 START_PROFILE_BYTES(syscall_pwrite, n);
293 result = sys_pwrite(fsp->fh->fd, data, n, offset);
294 END_PROFILE(syscall_pwrite);
296 if (result == -1 && errno == ESPIPE) {
297 /* Maintain the fiction that pipes can be sought on. */
298 result = SMB_VFS_WRITE(fsp, data, n);
301 #else /* HAVE_PWRITE */
305 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
310 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
314 result = SMB_VFS_WRITE(fsp, data, n);
317 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
320 #endif /* HAVE_PWRITE */
325 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
327 SMB_OFF_T result = 0;
329 START_PROFILE(syscall_lseek);
331 /* Cope with 'stat' file opens. */
332 if (fsp->fh->fd != -1)
333 result = sys_lseek(fsp->fh->fd, offset, whence);
336 * We want to maintain the fiction that we can seek
337 * on a fifo for file system purposes. This allows
338 * people to set up UNIX fifo's that feed data to Windows
342 if((result == -1) && (errno == ESPIPE)) {
347 END_PROFILE(syscall_lseek);
351 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
352 SMB_OFF_T offset, size_t n)
356 START_PROFILE_BYTES(syscall_sendfile, n);
357 result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
358 END_PROFILE(syscall_sendfile);
362 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
370 START_PROFILE_BYTES(syscall_recvfile, n);
371 result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
372 END_PROFILE(syscall_recvfile);
376 /*********************************************************
377 For rename across filesystems Patch from Warren Birnbaum
378 <warrenb@hpcvscdp.cv.hp.com>
379 **********************************************************/
381 static int copy_reg(const char *source, const char *dest)
383 SMB_STRUCT_STAT source_stats;
388 if (sys_lstat (source, &source_stats) == -1)
391 if (!S_ISREG (source_stats.st_mode))
394 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
397 if (unlink (dest) && errno != ENOENT)
401 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
403 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
407 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
411 * Try to preserve ownership. For non-root it might fail, but that's ok.
412 * But root probably wants to know, e.g. if NFS disallows it.
416 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
418 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
423 * fchown turns off set[ug]id bits for non-root,
424 * so do the chmod last.
427 #if defined(HAVE_FCHMOD)
428 if (fchmod (ofd, source_stats.st_mode & 07777))
430 if (chmod (dest, source_stats.st_mode & 07777))
434 if (close (ifd) == -1)
437 if (close (ofd) == -1)
440 /* Try to copy the old file's modtime and access time. */
444 tv.actime = source_stats.st_atime;
445 tv.modtime = source_stats.st_mtime;
449 if (unlink (source) == -1)
465 static int vfswrap_rename(vfs_handle_struct *handle, const char *oldname, const char *newname)
469 START_PROFILE(syscall_rename);
470 result = rename(oldname, newname);
471 if (errno == EXDEV) {
472 /* Rename across filesystems needed. */
473 result = copy_reg(oldname, newname);
476 END_PROFILE(syscall_rename);
480 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
485 START_PROFILE(syscall_fsync);
486 result = fsync(fsp->fh->fd);
487 END_PROFILE(syscall_fsync);
494 static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
498 START_PROFILE(syscall_stat);
499 result = sys_stat(fname, sbuf);
500 END_PROFILE(syscall_stat);
504 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
508 START_PROFILE(syscall_fstat);
509 result = sys_fstat(fsp->fh->fd, sbuf);
510 END_PROFILE(syscall_fstat);
514 int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
518 START_PROFILE(syscall_lstat);
519 result = sys_lstat(path, sbuf);
520 END_PROFILE(syscall_lstat);
524 static int vfswrap_unlink(vfs_handle_struct *handle, const char *path)
528 START_PROFILE(syscall_unlink);
529 result = unlink(path);
530 END_PROFILE(syscall_unlink);
534 static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
538 START_PROFILE(syscall_chmod);
541 * We need to do this due to the fact that the default POSIX ACL
542 * chmod modifies the ACL *mask* for the group owner, not the
543 * group owner bits directly. JRA.
548 int saved_errno = errno; /* We might get ENOSYS */
549 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
550 END_PROFILE(syscall_chmod);
553 /* Error - return the old errno. */
557 result = chmod(path, mode);
558 END_PROFILE(syscall_chmod);
562 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
566 START_PROFILE(syscall_fchmod);
569 * We need to do this due to the fact that the default POSIX ACL
570 * chmod modifies the ACL *mask* for the group owner, not the
571 * group owner bits directly. JRA.
575 int saved_errno = errno; /* We might get ENOSYS */
576 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
577 END_PROFILE(syscall_fchmod);
580 /* Error - return the old errno. */
584 #if defined(HAVE_FCHMOD)
585 result = fchmod(fsp->fh->fd, mode);
591 END_PROFILE(syscall_fchmod);
595 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
599 START_PROFILE(syscall_chown);
600 result = sys_chown(path, uid, gid);
601 END_PROFILE(syscall_chown);
605 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
610 START_PROFILE(syscall_fchown);
611 result = fchown(fsp->fh->fd, uid, gid);
612 END_PROFILE(syscall_fchown);
620 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
624 START_PROFILE(syscall_lchown);
625 result = sys_lchown(path, uid, gid);
626 END_PROFILE(syscall_lchown);
630 static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
634 START_PROFILE(syscall_chdir);
635 result = chdir(path);
636 END_PROFILE(syscall_chdir);
640 static char *vfswrap_getwd(vfs_handle_struct *handle, char *path)
644 START_PROFILE(syscall_getwd);
645 result = sys_getwd(path);
646 END_PROFILE(syscall_getwd);
650 /*********************************************************************
651 nsec timestamp resolution call. Convert down to whatever the underlying
653 **********************************************************************/
655 static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
659 START_PROFILE(syscall_ntimes);
660 #if defined(HAVE_UTIMES)
662 struct timeval tv[2];
663 tv[0] = convert_timespec_to_timeval(ts[0]);
664 tv[1] = convert_timespec_to_timeval(ts[1]);
665 result = utimes(path, tv);
667 #elif defined(HAVE_UTIME)
669 struct utimbuf times;
670 times.actime = convert_timespec_to_time_t(ts[0]);
671 times.modtime = convert_timespec_to_time_t(ts[1]);
672 result = utime(path, times);
678 END_PROFILE(syscall_ntimes);
682 /*********************************************************************
683 A version of ftruncate that will write the space on disk if strict
685 **********************************************************************/
687 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
690 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
691 unsigned char zero_space[4096];
692 SMB_OFF_T space_to_write;
697 if (SMB_VFS_FSTAT(fsp, &st) == -1)
700 space_to_write = len - st.st_size;
703 if (S_ISFIFO(st.st_mode))
707 if (st.st_size == len)
710 /* Shrink - just ftruncate. */
711 if (st.st_size > len)
712 return sys_ftruncate(fsp->fh->fd, len);
714 /* Write out the real space on disk. */
715 if (SMB_VFS_LSEEK(fsp, st.st_size, SEEK_SET) != st.st_size)
718 space_to_write = len - st.st_size;
720 memset(zero_space, '\0', sizeof(zero_space));
721 while ( space_to_write > 0) {
723 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
725 retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
729 space_to_write -= retlen;
732 /* Seek to where we were */
733 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
739 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
746 START_PROFILE(syscall_ftruncate);
748 if (lp_strict_allocate(SNUM(fsp->conn))) {
749 result = strict_allocate_ftruncate(handle, fsp, len);
750 END_PROFILE(syscall_ftruncate);
754 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
755 sys_ftruncate if the system supports it. Then I discovered that
756 you can have some filesystems that support ftruncate
757 expansion and some that don't! On Linux fat can't do
758 ftruncate extend but ext2 can. */
760 result = sys_ftruncate(fsp->fh->fd, len);
764 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
765 extend a file with ftruncate. Provide alternate implementation
767 currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
772 /* Do an fstat to see if the file is longer than the requested
773 size in which case the ftruncate above should have
774 succeeded or shorter, in which case seek to len - 1 and
775 write 1 byte of zero */
776 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
781 if (S_ISFIFO(st.st_mode)) {
787 if (st.st_size == len) {
792 if (st.st_size > len) {
793 /* the sys_ftruncate should have worked */
797 if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
800 if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
803 /* Seek to where we were */
804 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
810 END_PROFILE(syscall_ftruncate);
814 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
818 START_PROFILE(syscall_fcntl_lock);
819 result = fcntl_lock(fsp->fh->fd, op, offset, count, type);
820 END_PROFILE(syscall_fcntl_lock);
824 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
827 START_PROFILE(syscall_kernel_flock);
828 kernel_flock(fsp->fh->fd, share_mode);
829 END_PROFILE(syscall_kernel_flock);
833 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
837 START_PROFILE(syscall_fcntl_getlock);
838 result = fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
839 END_PROFILE(syscall_fcntl_getlock);
843 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
848 START_PROFILE(syscall_linux_setlease);
850 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
851 /* first set the signal handler */
852 if(linux_set_lease_sighandler(fsp->fh->fd) == -1) {
856 result = linux_setlease(fsp->fh->fd, leasetype);
860 END_PROFILE(syscall_linux_setlease);
864 static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
868 START_PROFILE(syscall_symlink);
869 result = sys_symlink(oldpath, newpath);
870 END_PROFILE(syscall_symlink);
874 static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
878 START_PROFILE(syscall_readlink);
879 result = sys_readlink(path, buf, bufsiz);
880 END_PROFILE(syscall_readlink);
884 static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
888 START_PROFILE(syscall_link);
889 result = sys_link(oldpath, newpath);
890 END_PROFILE(syscall_link);
894 static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
898 START_PROFILE(syscall_mknod);
899 result = sys_mknod(pathname, mode, dev);
900 END_PROFILE(syscall_mknod);
904 static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
908 START_PROFILE(syscall_realpath);
909 result = sys_realpath(path, resolved_path);
910 END_PROFILE(syscall_realpath);
914 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
915 struct sys_notify_context *ctx,
916 struct notify_entry *e,
917 void (*callback)(struct sys_notify_context *ctx,
919 struct notify_event *ev),
920 void *private_data, void *handle)
923 * So far inotify is the only supported default notify mechanism. If
924 * another platform like the the BSD's or a proprietary Unix comes
925 * along and wants another default, we can play the same trick we
926 * played with Posix ACLs.
928 * Until that is the case, hard-code inotify here.
931 if (lp_kernel_change_notify(ctx->conn->params)) {
932 return inotify_watch(ctx, e, callback, private_data, handle);
936 * Do nothing, leave everything to notify_internal.c
941 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
944 return chflags(path, flags);
951 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
953 return file_id_create_dev(dev, inode);
956 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
957 struct files_struct *fsp,
960 unsigned int *pnum_streams,
961 struct stream_struct **pstreams)
963 SMB_STRUCT_STAT sbuf;
965 unsigned int num_streams = 0;
966 struct stream_struct *streams = NULL;
969 if ((fsp != NULL) && (fsp->is_directory)) {
971 * No default streams on directories
976 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
977 ret = SMB_VFS_FSTAT(fsp, &sbuf);
980 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
984 return map_nt_error_from_unix(errno);
987 if (S_ISDIR(sbuf.st_mode)) {
991 streams = talloc(mem_ctx, struct stream_struct);
993 if (streams == NULL) {
994 return NT_STATUS_NO_MEMORY;
997 streams->size = sbuf.st_size;
998 streams->alloc_size = get_allocation_size(handle->conn, fsp, &sbuf);
1000 streams->name = talloc_strdup(streams, "::$DATA");
1001 if (streams->name == NULL) {
1002 TALLOC_FREE(streams);
1003 return NT_STATUS_NO_MEMORY;
1008 *pnum_streams = num_streams;
1009 *pstreams = streams;
1010 return NT_STATUS_OK;
1013 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1015 uint32 security_info, SEC_DESC **ppdesc)
1019 START_PROFILE(fget_nt_acl);
1020 result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1021 END_PROFILE(fget_nt_acl);
1025 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1027 uint32 security_info, SEC_DESC **ppdesc)
1031 START_PROFILE(get_nt_acl);
1032 result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1033 END_PROFILE(get_nt_acl);
1037 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, SEC_DESC *psd)
1041 START_PROFILE(fset_nt_acl);
1042 result = set_nt_acl(fsp, security_info_sent, psd);
1043 END_PROFILE(fset_nt_acl);
1047 static NTSTATUS vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
1051 START_PROFILE(set_nt_acl);
1052 result = set_nt_acl(fsp, security_info_sent, psd);
1053 END_PROFILE(set_nt_acl);
1057 static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
1065 START_PROFILE(chmod_acl);
1066 result = chmod_acl(handle->conn, name, mode);
1067 END_PROFILE(chmod_acl);
1072 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1080 START_PROFILE(fchmod_acl);
1081 result = fchmod_acl(fsp, mode);
1082 END_PROFILE(fchmod_acl);
1087 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1089 return sys_acl_get_entry(theacl, entry_id, entry_p);
1092 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)
1094 return sys_acl_get_tag_type(entry_d, tag_type_p);
1097 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1099 return sys_acl_get_permset(entry_d, permset_p);
1102 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1104 return sys_acl_get_qualifier(entry_d);
1107 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1109 return sys_acl_get_file(handle, path_p, type);
1112 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1114 return sys_acl_get_fd(handle, fsp);
1117 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1119 return sys_acl_clear_perms(permset);
1122 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1124 return sys_acl_add_perm(permset, perm);
1127 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1129 return sys_acl_to_text(theacl, plen);
1132 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1134 return sys_acl_init(count);
1137 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1139 return sys_acl_create_entry(pacl, pentry);
1142 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1144 return sys_acl_set_tag_type(entry, tagtype);
1147 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1149 return sys_acl_set_qualifier(entry, qual);
1152 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1154 return sys_acl_set_permset(entry, permset);
1157 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1159 return sys_acl_valid(theacl );
1162 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1164 return sys_acl_set_file(handle, name, acltype, theacl);
1167 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1169 return sys_acl_set_fd(handle, fsp, theacl);
1172 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1174 return sys_acl_delete_def_file(handle, path);
1177 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1179 return sys_acl_get_perm(permset, perm);
1182 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1184 return sys_acl_free_text(text);
1187 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1189 return sys_acl_free_acl(posix_acl);
1192 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1194 return sys_acl_free_qualifier(qualifier, tagtype);
1197 /****************************************************************
1198 Extended attribute operations.
1199 *****************************************************************/
1201 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1203 return sys_getxattr(path, name, value, size);
1206 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1208 return sys_lgetxattr(path, name, value, size);
1211 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1213 return sys_fgetxattr(fsp->fh->fd, name, value, size);
1216 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1218 return sys_listxattr(path, list, size);
1221 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1223 return sys_llistxattr(path, list, size);
1226 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1228 return sys_flistxattr(fsp->fh->fd, list, size);
1231 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1233 return sys_removexattr(path, name);
1236 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1238 return sys_lremovexattr(path, name);
1241 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1243 return sys_fremovexattr(fsp->fh->fd, name);
1246 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1248 return sys_setxattr(path, name, value, size, flags);
1251 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1253 return sys_lsetxattr(path, name, value, size, flags);
1256 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1258 return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1261 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1263 return sys_aio_read(aiocb);
1266 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1268 return sys_aio_write(aiocb);
1271 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1273 return sys_aio_return(aiocb);
1276 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1278 return sys_aio_cancel(fsp->fh->fd, aiocb);
1281 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1283 return sys_aio_error(aiocb);
1286 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1288 return sys_aio_fsync(op, aiocb);
1291 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)
1293 return sys_aio_suspend(aiocb, n, timeout);
1296 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1301 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1303 if (ISDOT(path) || ISDOTDOT(path)) {
1307 if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1308 #if defined(ENOTSUP)
1314 return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1317 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1319 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1320 #if defined(ENOTSUP)
1326 static vfs_op_tuple vfs_default_ops[] = {
1328 /* Disk operations */
1330 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1331 SMB_VFS_LAYER_OPAQUE},
1332 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1333 SMB_VFS_LAYER_OPAQUE},
1334 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1335 SMB_VFS_LAYER_OPAQUE},
1336 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1337 SMB_VFS_LAYER_OPAQUE},
1338 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1339 SMB_VFS_LAYER_OPAQUE},
1340 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1341 SMB_VFS_LAYER_OPAQUE},
1342 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1343 SMB_VFS_LAYER_OPAQUE},
1344 {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1345 SMB_VFS_LAYER_OPAQUE},
1347 /* Directory operations */
1349 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1350 SMB_VFS_LAYER_OPAQUE},
1351 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1352 SMB_VFS_LAYER_OPAQUE},
1353 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1354 SMB_VFS_LAYER_OPAQUE},
1355 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1356 SMB_VFS_LAYER_OPAQUE},
1357 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1358 SMB_VFS_LAYER_OPAQUE},
1359 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1360 SMB_VFS_LAYER_OPAQUE},
1361 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1362 SMB_VFS_LAYER_OPAQUE},
1363 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1364 SMB_VFS_LAYER_OPAQUE},
1366 /* File operations */
1368 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1369 SMB_VFS_LAYER_OPAQUE},
1370 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1371 SMB_VFS_LAYER_OPAQUE},
1372 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1373 SMB_VFS_LAYER_OPAQUE},
1374 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1375 SMB_VFS_LAYER_OPAQUE},
1376 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1377 SMB_VFS_LAYER_OPAQUE},
1378 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1379 SMB_VFS_LAYER_OPAQUE},
1380 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1381 SMB_VFS_LAYER_OPAQUE},
1382 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1383 SMB_VFS_LAYER_OPAQUE},
1384 {SMB_VFS_OP(vfswrap_recvfile), SMB_VFS_OP_RECVFILE,
1385 SMB_VFS_LAYER_OPAQUE},
1386 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1387 SMB_VFS_LAYER_OPAQUE},
1388 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1389 SMB_VFS_LAYER_OPAQUE},
1390 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1391 SMB_VFS_LAYER_OPAQUE},
1392 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1393 SMB_VFS_LAYER_OPAQUE},
1394 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1395 SMB_VFS_LAYER_OPAQUE},
1396 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1397 SMB_VFS_LAYER_OPAQUE},
1398 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1399 SMB_VFS_LAYER_OPAQUE},
1400 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1401 SMB_VFS_LAYER_OPAQUE},
1402 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1403 SMB_VFS_LAYER_OPAQUE},
1404 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1405 SMB_VFS_LAYER_OPAQUE},
1406 {SMB_VFS_OP(vfswrap_lchown), SMB_VFS_OP_LCHOWN,
1407 SMB_VFS_LAYER_OPAQUE},
1408 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1409 SMB_VFS_LAYER_OPAQUE},
1410 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1411 SMB_VFS_LAYER_OPAQUE},
1412 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1413 SMB_VFS_LAYER_OPAQUE},
1414 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1415 SMB_VFS_LAYER_OPAQUE},
1416 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1417 SMB_VFS_LAYER_OPAQUE},
1418 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1419 SMB_VFS_LAYER_OPAQUE},
1420 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1421 SMB_VFS_LAYER_OPAQUE},
1422 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1423 SMB_VFS_LAYER_OPAQUE},
1424 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1425 SMB_VFS_LAYER_OPAQUE},
1426 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1427 SMB_VFS_LAYER_OPAQUE},
1428 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1429 SMB_VFS_LAYER_OPAQUE},
1430 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1431 SMB_VFS_LAYER_OPAQUE},
1432 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1433 SMB_VFS_LAYER_OPAQUE},
1434 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1435 SMB_VFS_LAYER_OPAQUE},
1436 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1437 SMB_VFS_LAYER_OPAQUE},
1438 {SMB_VFS_OP(vfswrap_file_id_create), SMB_VFS_OP_FILE_ID_CREATE,
1439 SMB_VFS_LAYER_OPAQUE},
1440 {SMB_VFS_OP(vfswrap_streaminfo), SMB_VFS_OP_STREAMINFO,
1441 SMB_VFS_LAYER_OPAQUE},
1443 /* NT ACL operations. */
1445 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1446 SMB_VFS_LAYER_OPAQUE},
1447 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1448 SMB_VFS_LAYER_OPAQUE},
1449 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1450 SMB_VFS_LAYER_OPAQUE},
1451 {SMB_VFS_OP(vfswrap_set_nt_acl), SMB_VFS_OP_SET_NT_ACL,
1452 SMB_VFS_LAYER_OPAQUE},
1454 /* POSIX ACL operations. */
1456 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1457 SMB_VFS_LAYER_OPAQUE},
1458 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1459 SMB_VFS_LAYER_OPAQUE},
1460 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1461 SMB_VFS_LAYER_OPAQUE},
1462 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1463 SMB_VFS_LAYER_OPAQUE},
1464 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1465 SMB_VFS_LAYER_OPAQUE},
1466 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1467 SMB_VFS_LAYER_OPAQUE},
1468 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1469 SMB_VFS_LAYER_OPAQUE},
1470 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1471 SMB_VFS_LAYER_OPAQUE},
1472 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1473 SMB_VFS_LAYER_OPAQUE},
1474 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1475 SMB_VFS_LAYER_OPAQUE},
1476 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1477 SMB_VFS_LAYER_OPAQUE},
1478 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1479 SMB_VFS_LAYER_OPAQUE},
1480 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1481 SMB_VFS_LAYER_OPAQUE},
1482 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1483 SMB_VFS_LAYER_OPAQUE},
1484 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1485 SMB_VFS_LAYER_OPAQUE},
1486 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1487 SMB_VFS_LAYER_OPAQUE},
1488 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1489 SMB_VFS_LAYER_OPAQUE},
1490 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1491 SMB_VFS_LAYER_OPAQUE},
1492 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1493 SMB_VFS_LAYER_OPAQUE},
1494 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1495 SMB_VFS_LAYER_OPAQUE},
1496 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1497 SMB_VFS_LAYER_OPAQUE},
1498 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1499 SMB_VFS_LAYER_OPAQUE},
1500 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1501 SMB_VFS_LAYER_OPAQUE},
1502 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1503 SMB_VFS_LAYER_OPAQUE},
1505 /* EA operations. */
1507 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1508 SMB_VFS_LAYER_OPAQUE},
1509 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1510 SMB_VFS_LAYER_OPAQUE},
1511 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1512 SMB_VFS_LAYER_OPAQUE},
1513 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1514 SMB_VFS_LAYER_OPAQUE},
1515 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1516 SMB_VFS_LAYER_OPAQUE},
1517 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1518 SMB_VFS_LAYER_OPAQUE},
1519 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1520 SMB_VFS_LAYER_OPAQUE},
1521 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1522 SMB_VFS_LAYER_OPAQUE},
1523 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1524 SMB_VFS_LAYER_OPAQUE},
1525 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1526 SMB_VFS_LAYER_OPAQUE},
1527 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1528 SMB_VFS_LAYER_OPAQUE},
1529 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1530 SMB_VFS_LAYER_OPAQUE},
1532 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1533 SMB_VFS_LAYER_OPAQUE},
1534 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1535 SMB_VFS_LAYER_OPAQUE},
1536 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1537 SMB_VFS_LAYER_OPAQUE},
1538 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1539 SMB_VFS_LAYER_OPAQUE},
1540 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1541 SMB_VFS_LAYER_OPAQUE},
1542 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1543 SMB_VFS_LAYER_OPAQUE},
1544 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1545 SMB_VFS_LAYER_OPAQUE},
1547 {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1548 SMB_VFS_LAYER_OPAQUE},
1550 {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1551 SMB_VFS_LAYER_OPAQUE},
1552 {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1553 SMB_VFS_LAYER_OPAQUE},
1555 /* Finish VFS operations definition */
1557 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1561 NTSTATUS vfs_default_init(void);
1562 NTSTATUS vfs_default_init(void)
1564 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1566 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1567 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1568 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1569 smb_panic("operation(s) missing from default VFS module");
1572 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1573 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);