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)
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;
155 START_PROFILE(syscall_mkdir);
157 if (lp_inherit_acls(SNUM(handle->conn))
158 && parent_dirname(talloc_tos(), path, &parent, NULL)
159 && (has_dacl = directory_has_default_acl(handle->conn, parent)))
164 result = mkdir(path, mode);
166 if (result == 0 && !has_dacl) {
168 * We need to do this as the default behavior of POSIX ACLs
169 * is to set the mask to be the requested group permission
170 * bits, not the group permission bits to be the requested
171 * group permission bits. This is not what we want, as it will
172 * mess up any inherited ACL bits that were set. JRA.
174 int saved_errno = errno; /* We may get ENOSYS */
175 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
179 END_PROFILE(syscall_mkdir);
183 static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
187 START_PROFILE(syscall_rmdir);
188 result = rmdir(path);
189 END_PROFILE(syscall_rmdir);
193 static int vfswrap_closedir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
197 START_PROFILE(syscall_closedir);
198 result = sys_closedir(dirp);
199 END_PROFILE(syscall_closedir);
203 /* File operations */
205 static int vfswrap_open(vfs_handle_struct *handle, const char *fname,
206 files_struct *fsp, int flags, mode_t mode)
210 START_PROFILE(syscall_open);
211 result = sys_open(fname, flags, mode);
212 END_PROFILE(syscall_open);
216 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
217 struct smb_request *req,
218 uint16_t root_dir_fid,
220 uint32_t create_file_flags,
221 uint32_t access_mask,
222 uint32_t share_access,
223 uint32_t create_disposition,
224 uint32_t create_options,
225 uint32_t file_attributes,
226 uint32_t oplock_request,
227 uint64_t allocation_size,
228 struct security_descriptor *sd,
229 struct ea_list *ea_list,
230 files_struct **result,
232 SMB_STRUCT_STAT *psbuf)
234 return create_file_default(handle->conn, req, root_dir_fid, fname,
235 create_file_flags, access_mask, share_access,
236 create_disposition, create_options,
237 file_attributes, oplock_request,
238 allocation_size, sd, ea_list, result, pinfo,
242 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
246 START_PROFILE(syscall_close);
247 result = fd_close_posix(fsp);
248 END_PROFILE(syscall_close);
252 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
256 START_PROFILE_BYTES(syscall_read, n);
257 result = sys_read(fsp->fh->fd, data, n);
258 END_PROFILE(syscall_read);
262 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
263 size_t n, SMB_OFF_T offset)
267 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
268 START_PROFILE_BYTES(syscall_pread, n);
269 result = sys_pread(fsp->fh->fd, data, n, offset);
270 END_PROFILE(syscall_pread);
272 if (result == -1 && errno == ESPIPE) {
273 /* Maintain the fiction that pipes can be seeked (sought?) on. */
274 result = SMB_VFS_READ(fsp, data, n);
278 #else /* HAVE_PREAD */
282 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
283 if (curr == -1 && errno == ESPIPE) {
284 /* Maintain the fiction that pipes can be seeked (sought?) on. */
285 result = SMB_VFS_READ(fsp, data, n);
290 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
295 result = SMB_VFS_READ(fsp, data, n);
298 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
301 #endif /* HAVE_PREAD */
306 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
310 START_PROFILE_BYTES(syscall_write, n);
311 result = sys_write(fsp->fh->fd, data, n);
312 END_PROFILE(syscall_write);
316 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
317 size_t n, SMB_OFF_T offset)
321 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
322 START_PROFILE_BYTES(syscall_pwrite, n);
323 result = sys_pwrite(fsp->fh->fd, data, n, offset);
324 END_PROFILE(syscall_pwrite);
326 if (result == -1 && errno == ESPIPE) {
327 /* Maintain the fiction that pipes can be sought on. */
328 result = SMB_VFS_WRITE(fsp, data, n);
331 #else /* HAVE_PWRITE */
335 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
340 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
344 result = SMB_VFS_WRITE(fsp, data, n);
347 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
350 #endif /* HAVE_PWRITE */
355 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
357 SMB_OFF_T result = 0;
359 START_PROFILE(syscall_lseek);
361 /* Cope with 'stat' file opens. */
362 if (fsp->fh->fd != -1)
363 result = sys_lseek(fsp->fh->fd, offset, whence);
366 * We want to maintain the fiction that we can seek
367 * on a fifo for file system purposes. This allows
368 * people to set up UNIX fifo's that feed data to Windows
372 if((result == -1) && (errno == ESPIPE)) {
377 END_PROFILE(syscall_lseek);
381 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
382 SMB_OFF_T offset, size_t n)
386 START_PROFILE_BYTES(syscall_sendfile, n);
387 result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
388 END_PROFILE(syscall_sendfile);
392 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
400 START_PROFILE_BYTES(syscall_recvfile, n);
401 result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
402 END_PROFILE(syscall_recvfile);
406 /*********************************************************
407 For rename across filesystems Patch from Warren Birnbaum
408 <warrenb@hpcvscdp.cv.hp.com>
409 **********************************************************/
411 static int copy_reg(const char *source, const char *dest)
413 SMB_STRUCT_STAT source_stats;
418 if (sys_lstat (source, &source_stats) == -1)
421 if (!S_ISREG (source_stats.st_mode))
424 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
427 if (unlink (dest) && errno != ENOENT)
431 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
433 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
437 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
441 * Try to preserve ownership. For non-root it might fail, but that's ok.
442 * But root probably wants to know, e.g. if NFS disallows it.
446 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
448 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
453 * fchown turns off set[ug]id bits for non-root,
454 * so do the chmod last.
457 #if defined(HAVE_FCHMOD)
458 if (fchmod (ofd, source_stats.st_mode & 07777))
460 if (chmod (dest, source_stats.st_mode & 07777))
464 if (close (ifd) == -1)
467 if (close (ofd) == -1)
470 /* Try to copy the old file's modtime and access time. */
474 tv.actime = source_stats.st_atime;
475 tv.modtime = source_stats.st_mtime;
479 if (unlink (source) == -1)
495 static int vfswrap_rename(vfs_handle_struct *handle, const char *oldname, const char *newname)
499 START_PROFILE(syscall_rename);
500 result = rename(oldname, newname);
501 if ((result == -1) && (errno == EXDEV)) {
502 /* Rename across filesystems needed. */
503 result = copy_reg(oldname, newname);
506 END_PROFILE(syscall_rename);
510 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
515 START_PROFILE(syscall_fsync);
516 result = fsync(fsp->fh->fd);
517 END_PROFILE(syscall_fsync);
524 static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
528 START_PROFILE(syscall_stat);
529 result = sys_stat(fname, sbuf);
530 END_PROFILE(syscall_stat);
534 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
538 START_PROFILE(syscall_fstat);
539 result = sys_fstat(fsp->fh->fd, sbuf);
540 END_PROFILE(syscall_fstat);
544 int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
548 START_PROFILE(syscall_lstat);
549 result = sys_lstat(path, sbuf);
550 END_PROFILE(syscall_lstat);
554 static int vfswrap_unlink(vfs_handle_struct *handle, const char *path)
558 START_PROFILE(syscall_unlink);
559 result = unlink(path);
560 END_PROFILE(syscall_unlink);
564 static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
568 START_PROFILE(syscall_chmod);
571 * We need to do this due to the fact that the default POSIX ACL
572 * chmod modifies the ACL *mask* for the group owner, not the
573 * group owner bits directly. JRA.
578 int saved_errno = errno; /* We might get ENOSYS */
579 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
580 END_PROFILE(syscall_chmod);
583 /* Error - return the old errno. */
587 result = chmod(path, mode);
588 END_PROFILE(syscall_chmod);
592 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
596 START_PROFILE(syscall_fchmod);
599 * We need to do this due to the fact that the default POSIX ACL
600 * chmod modifies the ACL *mask* for the group owner, not the
601 * group owner bits directly. JRA.
605 int saved_errno = errno; /* We might get ENOSYS */
606 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
607 END_PROFILE(syscall_fchmod);
610 /* Error - return the old errno. */
614 #if defined(HAVE_FCHMOD)
615 result = fchmod(fsp->fh->fd, mode);
621 END_PROFILE(syscall_fchmod);
625 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
629 START_PROFILE(syscall_chown);
630 result = chown(path, uid, gid);
631 END_PROFILE(syscall_chown);
635 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
640 START_PROFILE(syscall_fchown);
641 result = fchown(fsp->fh->fd, uid, gid);
642 END_PROFILE(syscall_fchown);
650 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
654 START_PROFILE(syscall_lchown);
655 result = lchown(path, uid, gid);
656 END_PROFILE(syscall_lchown);
660 static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
664 START_PROFILE(syscall_chdir);
665 result = chdir(path);
666 END_PROFILE(syscall_chdir);
670 static char *vfswrap_getwd(vfs_handle_struct *handle, char *path)
674 START_PROFILE(syscall_getwd);
675 result = sys_getwd(path);
676 END_PROFILE(syscall_getwd);
680 /*********************************************************************
681 nsec timestamp resolution call. Convert down to whatever the underlying
683 **********************************************************************/
685 static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
689 START_PROFILE(syscall_ntimes);
690 #if defined(HAVE_UTIMES)
692 struct timeval tv[2];
693 tv[0] = convert_timespec_to_timeval(ts[0]);
694 tv[1] = convert_timespec_to_timeval(ts[1]);
695 result = utimes(path, tv);
697 result = utimes(path, NULL);
699 #elif defined(HAVE_UTIME)
701 struct utimbuf times;
702 times.actime = convert_timespec_to_time_t(ts[0]);
703 times.modtime = convert_timespec_to_time_t(ts[1]);
704 result = utime(path, times);
706 result = utime(path, NULL);
712 END_PROFILE(syscall_ntimes);
716 /*********************************************************************
717 A version of ftruncate that will write the space on disk if strict
719 **********************************************************************/
721 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
724 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
725 unsigned char zero_space[4096];
726 SMB_OFF_T space_to_write;
731 if (SMB_VFS_FSTAT(fsp, &st) == -1)
734 space_to_write = len - st.st_size;
737 if (S_ISFIFO(st.st_mode))
741 if (st.st_size == len)
744 /* Shrink - just ftruncate. */
745 if (st.st_size > len)
746 return sys_ftruncate(fsp->fh->fd, len);
748 /* available disk space is enough or not? */
749 if (lp_strict_allocate(SNUM(fsp->conn))){
750 uint64_t space_avail;
751 uint64_t bsize,dfree,dsize;
753 space_avail = get_dfree_info(fsp->conn,fsp->fsp_name,false,&bsize,&dfree,&dsize);
754 /* space_avail is 1k blocks */
755 if (space_avail == (uint64_t)-1 ||
756 ((uint64_t)space_to_write/1024 > space_avail) ) {
762 /* Write out the real space on disk. */
763 if (SMB_VFS_LSEEK(fsp, st.st_size, SEEK_SET) != st.st_size)
766 space_to_write = len - st.st_size;
768 memset(zero_space, '\0', sizeof(zero_space));
769 while ( space_to_write > 0) {
771 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
773 retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
777 space_to_write -= retlen;
780 /* Seek to where we were */
781 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
787 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
794 START_PROFILE(syscall_ftruncate);
796 if (lp_strict_allocate(SNUM(fsp->conn))) {
797 result = strict_allocate_ftruncate(handle, fsp, len);
798 END_PROFILE(syscall_ftruncate);
802 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
803 sys_ftruncate if the system supports it. Then I discovered that
804 you can have some filesystems that support ftruncate
805 expansion and some that don't! On Linux fat can't do
806 ftruncate extend but ext2 can. */
808 result = sys_ftruncate(fsp->fh->fd, len);
812 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
813 extend a file with ftruncate. Provide alternate implementation
815 currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
820 /* Do an fstat to see if the file is longer than the requested
821 size in which case the ftruncate above should have
822 succeeded or shorter, in which case seek to len - 1 and
823 write 1 byte of zero */
824 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
829 if (S_ISFIFO(st.st_mode)) {
835 if (st.st_size == len) {
840 if (st.st_size > len) {
841 /* the sys_ftruncate should have worked */
845 if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
848 if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
851 /* Seek to where we were */
852 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
858 END_PROFILE(syscall_ftruncate);
862 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
866 START_PROFILE(syscall_fcntl_lock);
867 result = fcntl_lock(fsp->fh->fd, op, offset, count, type);
868 END_PROFILE(syscall_fcntl_lock);
872 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
875 START_PROFILE(syscall_kernel_flock);
876 kernel_flock(fsp->fh->fd, share_mode);
877 END_PROFILE(syscall_kernel_flock);
881 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
885 START_PROFILE(syscall_fcntl_getlock);
886 result = fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
887 END_PROFILE(syscall_fcntl_getlock);
891 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
896 START_PROFILE(syscall_linux_setlease);
898 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
899 /* first set the signal handler */
900 if(linux_set_lease_sighandler(fsp->fh->fd) == -1) {
904 result = linux_setlease(fsp->fh->fd, leasetype);
908 END_PROFILE(syscall_linux_setlease);
912 static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
916 START_PROFILE(syscall_symlink);
917 result = symlink(oldpath, newpath);
918 END_PROFILE(syscall_symlink);
922 static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
926 START_PROFILE(syscall_readlink);
927 result = readlink(path, buf, bufsiz);
928 END_PROFILE(syscall_readlink);
932 static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
936 START_PROFILE(syscall_link);
937 result = link(oldpath, newpath);
938 END_PROFILE(syscall_link);
942 static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
946 START_PROFILE(syscall_mknod);
947 result = sys_mknod(pathname, mode, dev);
948 END_PROFILE(syscall_mknod);
952 static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
956 START_PROFILE(syscall_realpath);
957 result = realpath(path, resolved_path);
958 END_PROFILE(syscall_realpath);
962 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
963 struct sys_notify_context *ctx,
964 struct notify_entry *e,
965 void (*callback)(struct sys_notify_context *ctx,
967 struct notify_event *ev),
968 void *private_data, void *handle)
971 * So far inotify is the only supported default notify mechanism. If
972 * another platform like the the BSD's or a proprietary Unix comes
973 * along and wants another default, we can play the same trick we
974 * played with Posix ACLs.
976 * Until that is the case, hard-code inotify here.
979 if (lp_kernel_change_notify(ctx->conn->params)) {
980 return inotify_watch(ctx, e, callback, private_data, handle);
984 * Do nothing, leave everything to notify_internal.c
989 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
992 return chflags(path, flags);
999 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
1001 return file_id_create_dev(dev, inode);
1004 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1005 struct files_struct *fsp,
1007 TALLOC_CTX *mem_ctx,
1008 unsigned int *pnum_streams,
1009 struct stream_struct **pstreams)
1011 SMB_STRUCT_STAT sbuf;
1012 unsigned int num_streams = 0;
1013 struct stream_struct *streams = NULL;
1016 if ((fsp != NULL) && (fsp->is_directory)) {
1018 * No default streams on directories
1023 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1024 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1027 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
1031 return map_nt_error_from_unix(errno);
1034 if (S_ISDIR(sbuf.st_mode)) {
1038 streams = talloc(mem_ctx, struct stream_struct);
1040 if (streams == NULL) {
1041 return NT_STATUS_NO_MEMORY;
1044 streams->size = sbuf.st_size;
1045 streams->alloc_size = get_allocation_size(handle->conn, fsp, &sbuf);
1047 streams->name = talloc_strdup(streams, "::$DATA");
1048 if (streams->name == NULL) {
1049 TALLOC_FREE(streams);
1050 return NT_STATUS_NO_MEMORY;
1055 *pnum_streams = num_streams;
1056 *pstreams = streams;
1057 return NT_STATUS_OK;
1060 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1063 TALLOC_CTX *mem_ctx,
1066 return get_real_filename(handle->conn, path, name, mem_ctx,
1070 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1072 uint32 security_info, SEC_DESC **ppdesc)
1076 START_PROFILE(fget_nt_acl);
1077 result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1078 END_PROFILE(fget_nt_acl);
1082 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1084 uint32 security_info, SEC_DESC **ppdesc)
1088 START_PROFILE(get_nt_acl);
1089 result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1090 END_PROFILE(get_nt_acl);
1094 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1098 START_PROFILE(fset_nt_acl);
1099 result = set_nt_acl(fsp, security_info_sent, psd);
1100 END_PROFILE(fset_nt_acl);
1104 static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
1112 START_PROFILE(chmod_acl);
1113 result = chmod_acl(handle->conn, name, mode);
1114 END_PROFILE(chmod_acl);
1119 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1127 START_PROFILE(fchmod_acl);
1128 result = fchmod_acl(fsp, mode);
1129 END_PROFILE(fchmod_acl);
1134 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1136 return sys_acl_get_entry(theacl, entry_id, entry_p);
1139 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)
1141 return sys_acl_get_tag_type(entry_d, tag_type_p);
1144 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1146 return sys_acl_get_permset(entry_d, permset_p);
1149 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1151 return sys_acl_get_qualifier(entry_d);
1154 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1156 return sys_acl_get_file(handle, path_p, type);
1159 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1161 return sys_acl_get_fd(handle, fsp);
1164 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1166 return sys_acl_clear_perms(permset);
1169 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1171 return sys_acl_add_perm(permset, perm);
1174 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1176 return sys_acl_to_text(theacl, plen);
1179 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1181 return sys_acl_init(count);
1184 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1186 return sys_acl_create_entry(pacl, pentry);
1189 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1191 return sys_acl_set_tag_type(entry, tagtype);
1194 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1196 return sys_acl_set_qualifier(entry, qual);
1199 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1201 return sys_acl_set_permset(entry, permset);
1204 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1206 return sys_acl_valid(theacl );
1209 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1211 return sys_acl_set_file(handle, name, acltype, theacl);
1214 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1216 return sys_acl_set_fd(handle, fsp, theacl);
1219 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1221 return sys_acl_delete_def_file(handle, path);
1224 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1226 return sys_acl_get_perm(permset, perm);
1229 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1231 return sys_acl_free_text(text);
1234 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1236 return sys_acl_free_acl(posix_acl);
1239 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1241 return sys_acl_free_qualifier(qualifier, tagtype);
1244 /****************************************************************
1245 Extended attribute operations.
1246 *****************************************************************/
1248 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1250 return sys_getxattr(path, name, value, size);
1253 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1255 return sys_lgetxattr(path, name, value, size);
1258 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1260 return sys_fgetxattr(fsp->fh->fd, name, value, size);
1263 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1265 return sys_listxattr(path, list, size);
1268 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1270 return sys_llistxattr(path, list, size);
1273 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1275 return sys_flistxattr(fsp->fh->fd, list, size);
1278 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1280 return sys_removexattr(path, name);
1283 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1285 return sys_lremovexattr(path, name);
1288 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1290 return sys_fremovexattr(fsp->fh->fd, name);
1293 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1295 return sys_setxattr(path, name, value, size, flags);
1298 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1300 return sys_lsetxattr(path, name, value, size, flags);
1303 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1305 return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1308 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1310 return sys_aio_read(aiocb);
1313 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1315 return sys_aio_write(aiocb);
1318 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1320 return sys_aio_return(aiocb);
1323 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1325 return sys_aio_cancel(fsp->fh->fd, aiocb);
1328 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1330 return sys_aio_error(aiocb);
1333 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1335 return sys_aio_fsync(op, aiocb);
1338 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)
1340 return sys_aio_suspend(aiocb, n, timeout);
1343 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1348 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1350 if (ISDOT(path) || ISDOTDOT(path)) {
1354 if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1355 #if defined(ENOTSUP)
1361 return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1364 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1366 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1367 #if defined(ENOTSUP)
1373 static vfs_op_tuple vfs_default_ops[] = {
1375 /* Disk operations */
1377 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1378 SMB_VFS_LAYER_OPAQUE},
1379 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1380 SMB_VFS_LAYER_OPAQUE},
1381 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1382 SMB_VFS_LAYER_OPAQUE},
1383 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1384 SMB_VFS_LAYER_OPAQUE},
1385 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1386 SMB_VFS_LAYER_OPAQUE},
1387 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1388 SMB_VFS_LAYER_OPAQUE},
1389 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1390 SMB_VFS_LAYER_OPAQUE},
1391 {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1392 SMB_VFS_LAYER_OPAQUE},
1394 /* Directory operations */
1396 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1397 SMB_VFS_LAYER_OPAQUE},
1398 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1399 SMB_VFS_LAYER_OPAQUE},
1400 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1401 SMB_VFS_LAYER_OPAQUE},
1402 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1403 SMB_VFS_LAYER_OPAQUE},
1404 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1405 SMB_VFS_LAYER_OPAQUE},
1406 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1407 SMB_VFS_LAYER_OPAQUE},
1408 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1409 SMB_VFS_LAYER_OPAQUE},
1410 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1411 SMB_VFS_LAYER_OPAQUE},
1413 /* File operations */
1415 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1416 SMB_VFS_LAYER_OPAQUE},
1417 {SMB_VFS_OP(vfswrap_create_file), SMB_VFS_OP_CREATE_FILE,
1418 SMB_VFS_LAYER_OPAQUE},
1419 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1420 SMB_VFS_LAYER_OPAQUE},
1421 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1422 SMB_VFS_LAYER_OPAQUE},
1423 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1424 SMB_VFS_LAYER_OPAQUE},
1425 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1426 SMB_VFS_LAYER_OPAQUE},
1427 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1428 SMB_VFS_LAYER_OPAQUE},
1429 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1430 SMB_VFS_LAYER_OPAQUE},
1431 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1432 SMB_VFS_LAYER_OPAQUE},
1433 {SMB_VFS_OP(vfswrap_recvfile), SMB_VFS_OP_RECVFILE,
1434 SMB_VFS_LAYER_OPAQUE},
1435 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1436 SMB_VFS_LAYER_OPAQUE},
1437 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1438 SMB_VFS_LAYER_OPAQUE},
1439 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1440 SMB_VFS_LAYER_OPAQUE},
1441 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1442 SMB_VFS_LAYER_OPAQUE},
1443 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1444 SMB_VFS_LAYER_OPAQUE},
1445 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1446 SMB_VFS_LAYER_OPAQUE},
1447 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1448 SMB_VFS_LAYER_OPAQUE},
1449 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1450 SMB_VFS_LAYER_OPAQUE},
1451 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1452 SMB_VFS_LAYER_OPAQUE},
1453 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1454 SMB_VFS_LAYER_OPAQUE},
1455 {SMB_VFS_OP(vfswrap_lchown), SMB_VFS_OP_LCHOWN,
1456 SMB_VFS_LAYER_OPAQUE},
1457 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1458 SMB_VFS_LAYER_OPAQUE},
1459 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1460 SMB_VFS_LAYER_OPAQUE},
1461 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1462 SMB_VFS_LAYER_OPAQUE},
1463 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1464 SMB_VFS_LAYER_OPAQUE},
1465 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1466 SMB_VFS_LAYER_OPAQUE},
1467 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1468 SMB_VFS_LAYER_OPAQUE},
1469 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1470 SMB_VFS_LAYER_OPAQUE},
1471 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1472 SMB_VFS_LAYER_OPAQUE},
1473 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1474 SMB_VFS_LAYER_OPAQUE},
1475 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1476 SMB_VFS_LAYER_OPAQUE},
1477 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1478 SMB_VFS_LAYER_OPAQUE},
1479 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1480 SMB_VFS_LAYER_OPAQUE},
1481 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1482 SMB_VFS_LAYER_OPAQUE},
1483 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1484 SMB_VFS_LAYER_OPAQUE},
1485 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1486 SMB_VFS_LAYER_OPAQUE},
1487 {SMB_VFS_OP(vfswrap_file_id_create), SMB_VFS_OP_FILE_ID_CREATE,
1488 SMB_VFS_LAYER_OPAQUE},
1489 {SMB_VFS_OP(vfswrap_streaminfo), SMB_VFS_OP_STREAMINFO,
1490 SMB_VFS_LAYER_OPAQUE},
1491 {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1492 SMB_VFS_LAYER_OPAQUE},
1494 /* NT ACL operations. */
1496 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1497 SMB_VFS_LAYER_OPAQUE},
1498 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1499 SMB_VFS_LAYER_OPAQUE},
1500 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1501 SMB_VFS_LAYER_OPAQUE},
1503 /* POSIX ACL operations. */
1505 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1506 SMB_VFS_LAYER_OPAQUE},
1507 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1508 SMB_VFS_LAYER_OPAQUE},
1509 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1510 SMB_VFS_LAYER_OPAQUE},
1511 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1512 SMB_VFS_LAYER_OPAQUE},
1513 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1514 SMB_VFS_LAYER_OPAQUE},
1515 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1516 SMB_VFS_LAYER_OPAQUE},
1517 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1518 SMB_VFS_LAYER_OPAQUE},
1519 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1520 SMB_VFS_LAYER_OPAQUE},
1521 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1522 SMB_VFS_LAYER_OPAQUE},
1523 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1524 SMB_VFS_LAYER_OPAQUE},
1525 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1526 SMB_VFS_LAYER_OPAQUE},
1527 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1528 SMB_VFS_LAYER_OPAQUE},
1529 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1530 SMB_VFS_LAYER_OPAQUE},
1531 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1532 SMB_VFS_LAYER_OPAQUE},
1533 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1534 SMB_VFS_LAYER_OPAQUE},
1535 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1536 SMB_VFS_LAYER_OPAQUE},
1537 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1538 SMB_VFS_LAYER_OPAQUE},
1539 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1540 SMB_VFS_LAYER_OPAQUE},
1541 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1542 SMB_VFS_LAYER_OPAQUE},
1543 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1544 SMB_VFS_LAYER_OPAQUE},
1545 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1546 SMB_VFS_LAYER_OPAQUE},
1547 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1548 SMB_VFS_LAYER_OPAQUE},
1549 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1550 SMB_VFS_LAYER_OPAQUE},
1551 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1552 SMB_VFS_LAYER_OPAQUE},
1554 /* EA operations. */
1556 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1557 SMB_VFS_LAYER_OPAQUE},
1558 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1559 SMB_VFS_LAYER_OPAQUE},
1560 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1561 SMB_VFS_LAYER_OPAQUE},
1562 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1563 SMB_VFS_LAYER_OPAQUE},
1564 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1565 SMB_VFS_LAYER_OPAQUE},
1566 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1567 SMB_VFS_LAYER_OPAQUE},
1568 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1569 SMB_VFS_LAYER_OPAQUE},
1570 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1571 SMB_VFS_LAYER_OPAQUE},
1572 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1573 SMB_VFS_LAYER_OPAQUE},
1574 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1575 SMB_VFS_LAYER_OPAQUE},
1576 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1577 SMB_VFS_LAYER_OPAQUE},
1578 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1579 SMB_VFS_LAYER_OPAQUE},
1581 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1582 SMB_VFS_LAYER_OPAQUE},
1583 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1584 SMB_VFS_LAYER_OPAQUE},
1585 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1586 SMB_VFS_LAYER_OPAQUE},
1587 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1588 SMB_VFS_LAYER_OPAQUE},
1589 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1590 SMB_VFS_LAYER_OPAQUE},
1591 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1592 SMB_VFS_LAYER_OPAQUE},
1593 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1594 SMB_VFS_LAYER_OPAQUE},
1596 {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1597 SMB_VFS_LAYER_OPAQUE},
1599 {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1600 SMB_VFS_LAYER_OPAQUE},
1601 {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1602 SMB_VFS_LAYER_OPAQUE},
1604 /* Finish VFS operations definition */
1606 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1610 NTSTATUS vfs_default_init(void);
1611 NTSTATUS vfs_default_init(void)
1613 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1615 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1616 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1617 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1618 smb_panic("operation(s) missing from default VFS module");
1621 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1622 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);