2 Unix SMB/CIFS implementation.
3 Wrap disk only vfs functions to sidestep dodgy compilers.
4 Copyright (C) Tim Potter 1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define DBGC_CLASS DBGC_VFS
27 /* Check for NULL pointer parameters in vfswrap_* functions */
29 /* We don't want to have NULL function pointers lying around. Someone
30 is sure to try and execute them. These stubs are used to prevent
33 int vfswrap_dummy_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user)
35 return 0; /* Return >= 0 for success */
38 void vfswrap_dummy_disconnect(vfs_handle_struct *handle, connection_struct *conn)
44 SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle, connection_struct *conn, const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
45 SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
49 result = sys_disk_free(conn, path, small_query, bsize, dfree, dsize);
53 int vfswrap_get_quota(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
55 #ifdef HAVE_SYS_QUOTAS
58 START_PROFILE(syscall_get_quota);
59 result = sys_get_quota(conn->connectpath, qtype, id, qt);
60 END_PROFILE(syscall_get_quota);
68 int vfswrap_set_quota(struct vfs_handle_struct *handle, struct connection_struct *conn, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
70 #ifdef HAVE_SYS_QUOTAS
73 START_PROFILE(syscall_set_quota);
74 result = sys_set_quota(conn->connectpath, qtype, id, qt);
75 END_PROFILE(syscall_set_quota);
83 int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, BOOL labels)
86 return -1; /* Not implemented. */
89 int vfswrap_statvfs(struct vfs_handle_struct *handle, struct connection_struct *conn, const char *path, vfs_statvfs_struct *statbuf)
91 return sys_statvfs(path, statbuf);
94 /* Directory operations */
96 SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle, connection_struct *conn, const char *fname, const char *mask, uint32 attr)
98 SMB_STRUCT_DIR *result;
100 START_PROFILE(syscall_opendir);
101 result = sys_opendir(fname);
102 END_PROFILE(syscall_opendir);
106 SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
108 SMB_STRUCT_DIRENT *result;
110 START_PROFILE(syscall_readdir);
111 result = sys_readdir(dirp);
112 END_PROFILE(syscall_readdir);
116 void vfswrap_seekdir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp, long offset)
118 START_PROFILE(syscall_seekdir);
119 sys_seekdir(dirp, offset);
120 END_PROFILE(syscall_seekdir);
123 long vfswrap_telldir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
126 START_PROFILE(syscall_telldir);
127 result = sys_telldir(dirp);
128 END_PROFILE(syscall_telldir);
132 void vfswrap_rewinddir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
134 START_PROFILE(syscall_rewinddir);
136 END_PROFILE(syscall_rewinddir);
139 int vfswrap_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
142 BOOL has_dacl = False;
144 START_PROFILE(syscall_mkdir);
146 if (lp_inherit_acls(SNUM(conn)) && (has_dacl = directory_has_default_acl(conn, parent_dirname(path))))
149 result = mkdir(path, mode);
151 if (result == 0 && !has_dacl) {
153 * We need to do this as the default behavior of POSIX ACLs
154 * is to set the mask to be the requested group permission
155 * bits, not the group permission bits to be the requested
156 * group permission bits. This is not what we want, as it will
157 * mess up any inherited ACL bits that were set. JRA.
159 int saved_errno = errno; /* We may get ENOSYS */
160 if ((SMB_VFS_CHMOD_ACL(conn, path, mode) == -1) && (errno == ENOSYS))
164 END_PROFILE(syscall_mkdir);
168 int vfswrap_rmdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
172 START_PROFILE(syscall_rmdir);
173 result = rmdir(path);
174 END_PROFILE(syscall_rmdir);
178 int vfswrap_closedir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp)
182 START_PROFILE(syscall_closedir);
183 result = sys_closedir(dirp);
184 END_PROFILE(syscall_closedir);
188 /* File operations */
190 int vfswrap_open(vfs_handle_struct *handle, connection_struct *conn, const char *fname, int flags, mode_t mode)
194 START_PROFILE(syscall_open);
195 result = sys_open(fname, flags, mode);
196 END_PROFILE(syscall_open);
200 int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
204 START_PROFILE(syscall_close);
207 END_PROFILE(syscall_close);
211 ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
215 START_PROFILE_BYTES(syscall_read, n);
216 result = sys_read(fd, data, n);
217 END_PROFILE(syscall_read);
221 ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
222 size_t n, SMB_OFF_T offset)
226 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
227 START_PROFILE_BYTES(syscall_pread, n);
228 result = sys_pread(fd, data, n, offset);
229 END_PROFILE(syscall_pread);
231 if (result == -1 && errno == ESPIPE) {
232 /* Maintain the fiction that pipes can be seeked (sought?) on. */
233 result = SMB_VFS_READ(fsp, fd, data, n);
237 #else /* HAVE_PREAD */
241 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
242 if (curr == -1 && errno == ESPIPE) {
243 /* Maintain the fiction that pipes can be seeked (sought?) on. */
244 result = SMB_VFS_READ(fsp, fd, data, n);
249 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
254 result = SMB_VFS_READ(fsp, fd, data, n);
257 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
260 #endif /* HAVE_PREAD */
265 ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
269 START_PROFILE_BYTES(syscall_write, n);
270 result = sys_write(fd, data, n);
271 END_PROFILE(syscall_write);
275 ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
276 size_t n, SMB_OFF_T offset)
280 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
281 START_PROFILE_BYTES(syscall_pwrite, n);
282 result = sys_pwrite(fd, data, n, offset);
283 END_PROFILE(syscall_pwrite);
285 if (result == -1 && errno == ESPIPE) {
286 /* Maintain the fiction that pipes can be sought on. */
287 result = SMB_VFS_WRITE(fsp, fd, data, n);
290 #else /* HAVE_PWRITE */
294 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
299 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
303 result = SMB_VFS_WRITE(fsp, fd, data, n);
306 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
309 #endif /* HAVE_PWRITE */
314 SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
316 SMB_OFF_T result = 0;
318 START_PROFILE(syscall_lseek);
320 /* Cope with 'stat' file opens. */
322 result = sys_lseek(filedes, offset, whence);
325 * We want to maintain the fiction that we can seek
326 * on a fifo for file system purposes. This allows
327 * people to set up UNIX fifo's that feed data to Windows
331 if((result == -1) && (errno == ESPIPE)) {
336 END_PROFILE(syscall_lseek);
340 ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
341 SMB_OFF_T offset, size_t n)
345 START_PROFILE_BYTES(syscall_sendfile, n);
346 result = sys_sendfile(tofd, fromfd, hdr, offset, n);
347 END_PROFILE(syscall_sendfile);
351 /*********************************************************
352 For rename across filesystems Patch from Warren Birnbaum
353 <warrenb@hpcvscdp.cv.hp.com>
354 **********************************************************/
356 static int copy_reg(const char *source, const char *dest)
358 SMB_STRUCT_STAT source_stats;
363 if (sys_lstat (source, &source_stats) == -1)
366 if (!S_ISREG (source_stats.st_mode))
369 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
372 if (unlink (dest) && errno != ENOENT)
376 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
378 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
382 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
386 * Try to preserve ownership. For non-root it might fail, but that's ok.
387 * But root probably wants to know, e.g. if NFS disallows it.
391 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
393 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
398 * fchown turns off set[ug]id bits for non-root,
399 * so do the chmod last.
402 #if defined(HAVE_FCHMOD)
403 if (fchmod (ofd, source_stats.st_mode & 07777))
405 if (chmod (dest, source_stats.st_mode & 07777))
409 if (close (ifd) == -1)
412 if (close (ofd) == -1)
415 /* Try to copy the old file's modtime and access time. */
419 tv.actime = source_stats.st_atime;
420 tv.modtime = source_stats.st_mtime;
424 if (unlink (source) == -1)
440 int vfswrap_rename(vfs_handle_struct *handle, connection_struct *conn, const char *oldname, const char *newname)
444 START_PROFILE(syscall_rename);
445 result = rename(oldname, newname);
446 if (errno == EXDEV) {
447 /* Rename across filesystems needed. */
448 result = copy_reg(oldname, newname);
451 END_PROFILE(syscall_rename);
455 int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
460 START_PROFILE(syscall_fsync);
462 END_PROFILE(syscall_fsync);
469 int vfswrap_stat(vfs_handle_struct *handle, connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
473 START_PROFILE(syscall_stat);
474 result = sys_stat(fname, sbuf);
475 END_PROFILE(syscall_stat);
479 int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
483 START_PROFILE(syscall_fstat);
484 result = sys_fstat(fd, sbuf);
485 END_PROFILE(syscall_fstat);
489 int vfswrap_lstat(vfs_handle_struct *handle, connection_struct *conn, const char *path, SMB_STRUCT_STAT *sbuf)
493 START_PROFILE(syscall_lstat);
494 result = sys_lstat(path, sbuf);
495 END_PROFILE(syscall_lstat);
499 int vfswrap_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *path)
503 START_PROFILE(syscall_unlink);
504 result = unlink(path);
505 END_PROFILE(syscall_unlink);
509 int vfswrap_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode)
513 START_PROFILE(syscall_chmod);
516 * We need to do this due to the fact that the default POSIX ACL
517 * chmod modifies the ACL *mask* for the group owner, not the
518 * group owner bits directly. JRA.
523 int saved_errno = errno; /* We might get ENOSYS */
524 if ((result = SMB_VFS_CHMOD_ACL(conn, path, mode)) == 0) {
525 END_PROFILE(syscall_chmod);
528 /* Error - return the old errno. */
532 result = chmod(path, mode);
533 END_PROFILE(syscall_chmod);
537 int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
541 START_PROFILE(syscall_fchmod);
544 * We need to do this due to the fact that the default POSIX ACL
545 * chmod modifies the ACL *mask* for the group owner, not the
546 * group owner bits directly. JRA.
550 int saved_errno = errno; /* We might get ENOSYS */
551 if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
552 END_PROFILE(syscall_chmod);
555 /* Error - return the old errno. */
559 #if defined(HAVE_FCHMOD)
560 result = fchmod(fd, mode);
566 END_PROFILE(syscall_fchmod);
570 int vfswrap_chown(vfs_handle_struct *handle, connection_struct *conn, const char *path, uid_t uid, gid_t gid)
574 START_PROFILE(syscall_chown);
575 result = sys_chown(path, uid, gid);
576 END_PROFILE(syscall_chown);
580 int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
585 START_PROFILE(syscall_fchown);
586 result = fchown(fd, uid, gid);
587 END_PROFILE(syscall_fchown);
595 int vfswrap_chdir(vfs_handle_struct *handle, connection_struct *conn, const char *path)
599 START_PROFILE(syscall_chdir);
600 result = chdir(path);
601 END_PROFILE(syscall_chdir);
605 char *vfswrap_getwd(vfs_handle_struct *handle, connection_struct *conn, char *path)
609 START_PROFILE(syscall_getwd);
610 result = sys_getwd(path);
611 END_PROFILE(syscall_getwd);
615 int vfswrap_utime(vfs_handle_struct *handle, connection_struct *conn, const char *path, struct utimbuf *times)
619 START_PROFILE(syscall_utime);
620 result = utime(path, times);
621 END_PROFILE(syscall_utime);
625 /*********************************************************************
626 A version of ftruncate that will write the space on disk if strict
628 **********************************************************************/
630 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
633 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
634 unsigned char zero_space[4096];
635 SMB_OFF_T space_to_write;
640 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
643 space_to_write = len - st.st_size;
646 if (S_ISFIFO(st.st_mode))
650 if (st.st_size == len)
653 /* Shrink - just ftruncate. */
654 if (st.st_size > len)
655 return sys_ftruncate(fd, len);
657 /* Write out the real space on disk. */
658 if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
661 space_to_write = len - st.st_size;
663 memset(zero_space, '\0', sizeof(zero_space));
664 while ( space_to_write > 0) {
666 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
668 retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
672 space_to_write -= retlen;
675 /* Seek to where we were */
676 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
682 int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
689 START_PROFILE(syscall_ftruncate);
691 if (lp_strict_allocate(SNUM(fsp->conn))) {
692 result = strict_allocate_ftruncate(handle, fsp, fd, len);
693 END_PROFILE(syscall_ftruncate);
697 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
698 sys_ftruncate if the system supports it. Then I discovered that
699 you can have some filesystems that support ftruncate
700 expansion and some that don't! On Linux fat can't do
701 ftruncate extend but ext2 can. */
703 result = sys_ftruncate(fd, len);
707 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
708 extend a file with ftruncate. Provide alternate implementation
710 currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
715 /* Do an fstat to see if the file is longer than the requested
716 size in which case the ftruncate above should have
717 succeeded or shorter, in which case seek to len - 1 and
718 write 1 byte of zero */
719 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
724 if (S_ISFIFO(st.st_mode)) {
730 if (st.st_size == len) {
735 if (st.st_size > len) {
736 /* the sys_ftruncate should have worked */
740 if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
743 if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
746 /* Seek to where we were */
747 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
753 END_PROFILE(syscall_ftruncate);
757 BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
761 START_PROFILE(syscall_fcntl_lock);
762 result = fcntl_lock(fd, op, offset, count, type);
763 END_PROFILE(syscall_fcntl_lock);
767 BOOL vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
771 START_PROFILE(syscall_fcntl_getlock);
772 result = fcntl_getlock(fd, poffset, pcount, ptype, ppid);
773 END_PROFILE(syscall_fcntl_getlock);
777 int vfswrap_symlink(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
781 START_PROFILE(syscall_symlink);
782 result = sys_symlink(oldpath, newpath);
783 END_PROFILE(syscall_symlink);
787 int vfswrap_readlink(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *buf, size_t bufsiz)
791 START_PROFILE(syscall_readlink);
792 result = sys_readlink(path, buf, bufsiz);
793 END_PROFILE(syscall_readlink);
797 int vfswrap_link(vfs_handle_struct *handle, connection_struct *conn, const char *oldpath, const char *newpath)
801 START_PROFILE(syscall_link);
802 result = sys_link(oldpath, newpath);
803 END_PROFILE(syscall_link);
807 int vfswrap_mknod(vfs_handle_struct *handle, connection_struct *conn, const char *pathname, mode_t mode, SMB_DEV_T dev)
811 START_PROFILE(syscall_mknod);
812 result = sys_mknod(pathname, mode, dev);
813 END_PROFILE(syscall_mknod);
817 char *vfswrap_realpath(vfs_handle_struct *handle, connection_struct *conn, const char *path, char *resolved_path)
821 START_PROFILE(syscall_realpath);
822 result = sys_realpath(path, resolved_path);
823 END_PROFILE(syscall_realpath);
827 size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info, SEC_DESC **ppdesc)
831 START_PROFILE(fget_nt_acl);
832 result = get_nt_acl(fsp, security_info, ppdesc);
833 END_PROFILE(fget_nt_acl);
837 size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info, SEC_DESC **ppdesc)
841 START_PROFILE(get_nt_acl);
842 result = get_nt_acl(fsp, security_info, ppdesc);
843 END_PROFILE(get_nt_acl);
847 BOOL vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
851 START_PROFILE(fset_nt_acl);
852 result = set_nt_acl(fsp, security_info_sent, psd);
853 END_PROFILE(fset_nt_acl);
857 BOOL vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
861 START_PROFILE(set_nt_acl);
862 result = set_nt_acl(fsp, security_info_sent, psd);
863 END_PROFILE(set_nt_acl);
867 int vfswrap_chmod_acl(vfs_handle_struct *handle, connection_struct *conn, const char *name, mode_t mode)
875 START_PROFILE(chmod_acl);
876 result = chmod_acl(conn, name, mode);
877 END_PROFILE(chmod_acl);
882 int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
890 START_PROFILE(fchmod_acl);
891 result = fchmod_acl(fsp, fd, mode);
892 END_PROFILE(fchmod_acl);
897 int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
899 return sys_acl_get_entry(theacl, entry_id, entry_p);
902 int vfswrap_sys_acl_get_tag_type(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
904 return sys_acl_get_tag_type(entry_d, tag_type_p);
907 int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
909 return sys_acl_get_permset(entry_d, permset_p);
912 void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry_d)
914 return sys_acl_get_qualifier(entry_d);
917 SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, connection_struct *conn, const char *path_p, SMB_ACL_TYPE_T type)
919 return sys_acl_get_file(path_p, type);
922 SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
924 return sys_acl_get_fd(fd);
927 int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset)
929 return sys_acl_clear_perms(permset);
932 int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
934 return sys_acl_add_perm(permset, perm);
937 char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl, ssize_t *plen)
939 return sys_acl_to_text(theacl, plen);
942 SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, connection_struct *conn, int count)
944 return sys_acl_init(count);
947 int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
949 return sys_acl_create_entry(pacl, pentry);
952 int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
954 return sys_acl_set_tag_type(entry, tagtype);
957 int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, void *qual)
959 return sys_acl_set_qualifier(entry, qual);
962 int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
964 return sys_acl_set_permset(entry, permset);
967 int vfswrap_sys_acl_valid(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T theacl )
969 return sys_acl_valid(theacl );
972 int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, connection_struct *conn, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
974 return sys_acl_set_file(name, acltype, theacl);
977 int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
979 return sys_acl_set_fd(fd, theacl);
982 int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, connection_struct *conn, const char *path)
984 return sys_acl_delete_def_file(path);
987 int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
989 return sys_acl_get_perm(permset, perm);
992 int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, connection_struct *conn, char *text)
994 return sys_acl_free_text(text);
997 int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, connection_struct *conn, SMB_ACL_T posix_acl)
999 return sys_acl_free_acl(posix_acl);
1002 int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, connection_struct *conn, void *qualifier, SMB_ACL_TAG_T tagtype)
1004 return sys_acl_free_qualifier(qualifier, tagtype);
1007 /****************************************************************
1008 Extended attribute operations.
1009 *****************************************************************/
1011 ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,struct connection_struct *conn,const char *path, const char *name, void *value, size_t size)
1013 return sys_getxattr(path, name, value, size);
1016 ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,struct connection_struct *conn,const char *path, const char *name, void *value, size_t size)
1018 return sys_lgetxattr(path, name, value, size);
1021 ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, void *value, size_t size)
1023 return sys_fgetxattr(fd, name, value, size);
1026 ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, char *list, size_t size)
1028 return sys_listxattr(path, list, size);
1031 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, char *list, size_t size)
1033 return sys_llistxattr(path, list, size);
1036 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, char *list, size_t size)
1038 return sys_flistxattr(fd, list, size);
1041 int vfswrap_removexattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name)
1043 return sys_removexattr(path, name);
1046 int vfswrap_lremovexattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name)
1048 return sys_lremovexattr(path, name);
1051 int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name)
1053 return sys_fremovexattr(fd, name);
1056 int vfswrap_setxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name, const void *value, size_t size, int flags)
1058 return sys_setxattr(path, name, value, size, flags);
1061 int vfswrap_lsetxattr(struct vfs_handle_struct *handle, struct connection_struct *conn,const char *path, const char *name, const void *value, size_t size, int flags)
1063 return sys_lsetxattr(path, name, value, size, flags);
1066 int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, const void *value, size_t size, int flags)
1068 return sys_fsetxattr(fd, name, value, size, flags);
1071 int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1073 return sys_aio_read(aiocb);
1076 int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1078 return sys_aio_write(aiocb);
1081 ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1083 return sys_aio_return(aiocb);
1086 int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_AIOCB *aiocb)
1088 return sys_aio_cancel(fd, aiocb);
1091 int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1093 return sys_aio_error(aiocb);
1096 int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1098 return sys_aio_fsync(op, aiocb);
1101 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)
1103 return sys_aio_suspend(aiocb, n, timeout);