source: branches/samba-3.0/source/modules/vfs_default.c

Last change on this file was 312, checked in by Herwig Bauernfeind, 16 years ago

Update 3.0 to final 3.0.36 (source)
File size: 39.4 KB
Line 
1/*
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
6
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 2 of the License, or
10 (at your option) any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20*/
21
22#include "includes.h"
23
24#undef DBGC_CLASS
25#define DBGC_CLASS DBGC_VFS
26
27/* Check for NULL pointer parameters in vfswrap_* functions */
28
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
31 this possibility. */
32
33static int vfswrap_connect(vfs_handle_struct *handle, const char *service, const char *user)
34{
35 return 0; /* Return >= 0 for success */
36}
37
38static void vfswrap_disconnect(vfs_handle_struct *handle)
39{
40}
41
42/* Disk operations */
43
44static SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle, const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
45 SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
46{
47 SMB_BIG_UINT result;
48
49 result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
50 return result;
51}
52
53static int vfswrap_get_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
54{
55#ifdef HAVE_SYS_QUOTAS
56 int result;
57
58 START_PROFILE(syscall_get_quota);
59 result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
60 END_PROFILE(syscall_get_quota);
61 return result;
62#else
63 errno = ENOSYS;
64 return -1;
65#endif
66}
67
68static int vfswrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
69{
70#ifdef HAVE_SYS_QUOTAS
71 int result;
72
73 START_PROFILE(syscall_set_quota);
74 result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
75 END_PROFILE(syscall_set_quota);
76 return result;
77#else
78 errno = ENOSYS;
79 return -1;
80#endif
81}
82
83static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, BOOL labels)
84{
85 errno = ENOSYS;
86 return -1; /* Not implemented. */
87}
88
89static int vfswrap_statvfs(struct vfs_handle_struct *handle, const char *path, vfs_statvfs_struct *statbuf)
90{
91 return sys_statvfs(path, statbuf);
92}
93
94/* Directory operations */
95
96static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attr)
97{
98 SMB_STRUCT_DIR *result;
99
100 START_PROFILE(syscall_opendir);
101 result = sys_opendir(fname);
102 END_PROFILE(syscall_opendir);
103 return result;
104}
105
106static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
107{
108 SMB_STRUCT_DIRENT *result;
109
110 START_PROFILE(syscall_readdir);
111 result = sys_readdir(dirp);
112 END_PROFILE(syscall_readdir);
113 return result;
114}
115
116static void vfswrap_seekdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset)
117{
118 START_PROFILE(syscall_seekdir);
119 sys_seekdir(dirp, offset);
120 END_PROFILE(syscall_seekdir);
121}
122
123static long vfswrap_telldir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
124{
125 long result;
126 START_PROFILE(syscall_telldir);
127 result = sys_telldir(dirp);
128 END_PROFILE(syscall_telldir);
129 return result;
130}
131
132static void vfswrap_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
133{
134 START_PROFILE(syscall_rewinddir);
135 sys_rewinddir(dirp);
136 END_PROFILE(syscall_rewinddir);
137}
138
139static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
140{
141 int result;
142 BOOL has_dacl = False;
143
144 START_PROFILE(syscall_mkdir);
145
146 if (lp_inherit_acls(SNUM(handle->conn)) && (has_dacl = directory_has_default_acl(handle->conn, parent_dirname(path))))
147 mode = 0777;
148
149 result = mkdir(path, mode);
150
151 if (result == 0 && !has_dacl) {
152 /*
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.
158 */
159 int saved_errno = errno; /* We may get ENOSYS */
160 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
161 errno = saved_errno;
162 }
163
164 END_PROFILE(syscall_mkdir);
165 return result;
166}
167
168static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
169{
170 int result;
171
172 START_PROFILE(syscall_rmdir);
173 result = rmdir(path);
174 END_PROFILE(syscall_rmdir);
175 return result;
176}
177
178static int vfswrap_closedir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
179{
180 int result;
181
182 START_PROFILE(syscall_closedir);
183 result = sys_closedir(dirp);
184 END_PROFILE(syscall_closedir);
185 return result;
186}
187
188/* File operations */
189
190static int vfswrap_open(vfs_handle_struct *handle, const char *fname,
191 files_struct *fsp, int flags, mode_t mode)
192{
193 int result;
194
195 START_PROFILE(syscall_open);
196 result = sys_open(fname, flags, mode);
197 END_PROFILE(syscall_open);
198 return result;
199}
200
201static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
202{
203 int result;
204
205 START_PROFILE(syscall_close);
206
207 result = close(fd);
208 END_PROFILE(syscall_close);
209 return result;
210}
211
212static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
213{
214 ssize_t result;
215
216 START_PROFILE_BYTES(syscall_read, n);
217 result = sys_read(fd, data, n);
218 END_PROFILE(syscall_read);
219 return result;
220}
221
222static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
223 size_t n, SMB_OFF_T offset)
224{
225 ssize_t result;
226
227#if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
228 START_PROFILE_BYTES(syscall_pread, n);
229 result = sys_pread(fd, data, n, offset);
230 END_PROFILE(syscall_pread);
231
232 if (result == -1 && errno == ESPIPE) {
233 /* Maintain the fiction that pipes can be seeked (sought?) on. */
234 result = SMB_VFS_READ(fsp, fd, data, n);
235 fsp->fh->pos = 0;
236 }
237
238#else /* HAVE_PREAD */
239 SMB_OFF_T curr;
240 int lerrno;
241
242 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
243 if (curr == -1 && errno == ESPIPE) {
244 /* Maintain the fiction that pipes can be seeked (sought?) on. */
245 result = SMB_VFS_READ(fsp, fd, data, n);
246 fsp->fh->pos = 0;
247 return result;
248 }
249
250 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
251 return -1;
252 }
253
254 errno = 0;
255 result = SMB_VFS_READ(fsp, fd, data, n);
256 lerrno = errno;
257
258 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
259 errno = lerrno;
260
261#endif /* HAVE_PREAD */
262
263 return result;
264}
265
266static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
267{
268 ssize_t result;
269
270 START_PROFILE_BYTES(syscall_write, n);
271 result = sys_write(fd, data, n);
272 END_PROFILE(syscall_write);
273 return result;
274}
275
276static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
277 size_t n, SMB_OFF_T offset)
278{
279 ssize_t result;
280
281#if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
282 START_PROFILE_BYTES(syscall_pwrite, n);
283 result = sys_pwrite(fd, data, n, offset);
284 END_PROFILE(syscall_pwrite);
285
286 if (result == -1 && errno == ESPIPE) {
287 /* Maintain the fiction that pipes can be sought on. */
288 result = SMB_VFS_WRITE(fsp, fd, data, n);
289 }
290
291#else /* HAVE_PWRITE */
292 SMB_OFF_T curr;
293 int lerrno;
294
295 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
296 if (curr == -1) {
297 return -1;
298 }
299
300 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
301 return -1;
302 }
303
304 result = SMB_VFS_WRITE(fsp, fd, data, n);
305 lerrno = errno;
306
307 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
308 errno = lerrno;
309
310#endif /* HAVE_PWRITE */
311
312 return result;
313}
314
315static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
316{
317 SMB_OFF_T result = 0;
318
319 START_PROFILE(syscall_lseek);
320
321 /* Cope with 'stat' file opens. */
322 if (filedes != -1)
323 result = sys_lseek(filedes, offset, whence);
324
325 /*
326 * We want to maintain the fiction that we can seek
327 * on a fifo for file system purposes. This allows
328 * people to set up UNIX fifo's that feed data to Windows
329 * applications. JRA.
330 */
331
332 if((result == -1) && (errno == ESPIPE)) {
333 result = 0;
334 errno = 0;
335 }
336
337 END_PROFILE(syscall_lseek);
338 return result;
339}
340
341static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
342 SMB_OFF_T offset, size_t n)
343{
344 ssize_t result;
345
346 START_PROFILE_BYTES(syscall_sendfile, n);
347 result = sys_sendfile(tofd, fromfd, hdr, offset, n);
348 END_PROFILE(syscall_sendfile);
349 return result;
350}
351
352/*********************************************************
353 For rename across filesystems Patch from Warren Birnbaum
354 <warrenb@hpcvscdp.cv.hp.com>
355**********************************************************/
356
357static int copy_reg(const char *source, const char *dest)
358{
359 SMB_STRUCT_STAT source_stats;
360 int saved_errno;
361 int ifd = -1;
362 int ofd = -1;
363
364 if (sys_lstat (source, &source_stats) == -1)
365 return -1;
366
367 if (!S_ISREG (source_stats.st_mode))
368 return -1;
369
370 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
371 return -1;
372
373 if (unlink (dest) && errno != ENOENT)
374 return -1;
375
376#ifdef O_NOFOLLOW
377 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
378#else
379 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
380#endif
381 goto err;
382
383 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
384 goto err;
385
386 /*
387 * Try to preserve ownership. For non-root it might fail, but that's ok.
388 * But root probably wants to know, e.g. if NFS disallows it.
389 */
390
391#ifdef HAVE_FCHOWN
392 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
393#else
394 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
395#endif
396 goto err;
397
398 /*
399 * fchown turns off set[ug]id bits for non-root,
400 * so do the chmod last.
401 */
402
403#if defined(HAVE_FCHMOD)
404 if (fchmod (ofd, source_stats.st_mode & 07777))
405#else
406 if (chmod (dest, source_stats.st_mode & 07777))
407#endif
408 goto err;
409
410 if (close (ifd) == -1)
411 goto err;
412
413 if (close (ofd) == -1)
414 return -1;
415
416 /* Try to copy the old file's modtime and access time. */
417 {
418 struct utimbuf tv;
419
420 tv.actime = source_stats.st_atime;
421 tv.modtime = source_stats.st_mtime;
422 utime(dest, &tv);
423 }
424
425 if (unlink (source) == -1)
426 return -1;
427
428 return 0;
429
430 err:
431
432 saved_errno = errno;
433 if (ifd != -1)
434 close(ifd);
435 if (ofd != -1)
436 close(ofd);
437 errno = saved_errno;
438 return -1;
439}
440
441static int vfswrap_rename(vfs_handle_struct *handle, const char *oldname, const char *newname)
442{
443 int result;
444
445 START_PROFILE(syscall_rename);
446 result = rename(oldname, newname);
447 if ((result == -1) && (errno == EXDEV)) {
448 /* Rename across filesystems needed. */
449 result = copy_reg(oldname, newname);
450 }
451
452 END_PROFILE(syscall_rename);
453 return result;
454}
455
456static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
457{
458#ifdef HAVE_FSYNC
459 int result;
460
461 START_PROFILE(syscall_fsync);
462 result = fsync(fd);
463 END_PROFILE(syscall_fsync);
464 return result;
465#else
466 return 0;
467#endif
468}
469
470static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
471{
472 int result;
473
474 START_PROFILE(syscall_stat);
475 result = sys_stat(fname, sbuf);
476 END_PROFILE(syscall_stat);
477 return result;
478}
479
480static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
481{
482 int result;
483
484 START_PROFILE(syscall_fstat);
485 result = sys_fstat(fd, sbuf);
486 END_PROFILE(syscall_fstat);
487 return result;
488}
489
490int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
491{
492 int result;
493
494 START_PROFILE(syscall_lstat);
495 result = sys_lstat(path, sbuf);
496 END_PROFILE(syscall_lstat);
497 return result;
498}
499
500static int vfswrap_unlink(vfs_handle_struct *handle, const char *path)
501{
502 int result;
503
504 START_PROFILE(syscall_unlink);
505 result = unlink(path);
506 END_PROFILE(syscall_unlink);
507 return result;
508}
509
510static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
511{
512 int result;
513
514 START_PROFILE(syscall_chmod);
515
516 /*
517 * We need to do this due to the fact that the default POSIX ACL
518 * chmod modifies the ACL *mask* for the group owner, not the
519 * group owner bits directly. JRA.
520 */
521
522
523 {
524 int saved_errno = errno; /* We might get ENOSYS */
525 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
526 END_PROFILE(syscall_chmod);
527 return result;
528 }
529 /* Error - return the old errno. */
530 errno = saved_errno;
531 }
532
533 result = chmod(path, mode);
534 END_PROFILE(syscall_chmod);
535 return result;
536}
537
538static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
539{
540 int result;
541
542 START_PROFILE(syscall_fchmod);
543
544 /*
545 * We need to do this due to the fact that the default POSIX ACL
546 * chmod modifies the ACL *mask* for the group owner, not the
547 * group owner bits directly. JRA.
548 */
549
550 {
551 int saved_errno = errno; /* We might get ENOSYS */
552 if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
553 END_PROFILE(syscall_fchmod);
554 return result;
555 }
556 /* Error - return the old errno. */
557 errno = saved_errno;
558 }
559
560#if defined(HAVE_FCHMOD)
561 result = fchmod(fd, mode);
562#else
563 result = -1;
564 errno = ENOSYS;
565#endif
566
567 END_PROFILE(syscall_fchmod);
568 return result;
569}
570
571static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
572{
573 int result;
574
575 START_PROFILE(syscall_chown);
576 result = sys_chown(path, uid, gid);
577 END_PROFILE(syscall_chown);
578 return result;
579}
580
581static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
582{
583#ifdef HAVE_FCHOWN
584 int result;
585
586 START_PROFILE(syscall_fchown);
587 result = fchown(fd, uid, gid);
588 END_PROFILE(syscall_fchown);
589 return result;
590#else
591 errno = ENOSYS;
592 return -1;
593#endif
594}
595
596static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
597{
598 int result;
599
600 START_PROFILE(syscall_chdir);
601 result = chdir(path);
602 END_PROFILE(syscall_chdir);
603 return result;
604}
605
606static char *vfswrap_getwd(vfs_handle_struct *handle, char *path)
607{
608 char *result;
609
610 START_PROFILE(syscall_getwd);
611 result = sys_getwd(path);
612 END_PROFILE(syscall_getwd);
613 return result;
614}
615
616/*********************************************************************
617 nsec timestamp resolution call. Convert down to whatever the underlying
618 system will support.
619**********************************************************************/
620
621static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
622{
623 int result;
624
625 START_PROFILE(syscall_ntimes);
626#if defined(HAVE_UTIMES)
627 {
628 struct timeval tv[2];
629 tv[0] = convert_timespec_to_timeval(ts[0]);
630 tv[1] = convert_timespec_to_timeval(ts[1]);
631 result = utimes(path, tv);
632 }
633#elif defined(HAVE_UTIME)
634 {
635 struct utimbuf times;
636 times.actime = convert_timespec_to_time_t(ts[0]);
637 times.modtime = convert_timespec_to_time_t(ts[1]);
638 result = utime(path, &times);
639 }
640#else
641 errno = ENOSYS;
642 result = -1;
643#endif
644 END_PROFILE(syscall_ntimes);
645 return result;
646}
647
648/*********************************************************************
649 A version of ftruncate that will write the space on disk if strict
650 allocate is set.
651**********************************************************************/
652
653static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
654{
655 SMB_STRUCT_STAT st;
656 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
657 unsigned char zero_space[4096];
658 SMB_OFF_T space_to_write;
659
660 if (currpos == -1)
661 return -1;
662
663 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
664 return -1;
665
666 space_to_write = len - st.st_size;
667
668#ifdef S_ISFIFO
669 if (S_ISFIFO(st.st_mode))
670 return 0;
671#endif
672
673 if (st.st_size == len)
674 return 0;
675
676 /* Shrink - just ftruncate. */
677 if (st.st_size > len)
678 return sys_ftruncate(fd, len);
679
680 /* Write out the real space on disk. */
681 if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
682 return -1;
683
684 space_to_write = len - st.st_size;
685
686 memset(zero_space, '\0', sizeof(zero_space));
687 while ( space_to_write > 0) {
688 SMB_OFF_T retlen;
689 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
690
691 retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
692 if (retlen <= 0)
693 return -1;
694
695 space_to_write -= retlen;
696 }
697
698 /* Seek to where we were */
699 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
700 return -1;
701
702 return 0;
703}
704
705static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
706{
707 int result = -1;
708 SMB_STRUCT_STAT st;
709 char c = 0;
710 SMB_OFF_T currpos;
711
712 START_PROFILE(syscall_ftruncate);
713
714 if (lp_strict_allocate(SNUM(fsp->conn))) {
715 result = strict_allocate_ftruncate(handle, fsp, fd, len);
716 END_PROFILE(syscall_ftruncate);
717 return result;
718 }
719
720 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
721 sys_ftruncate if the system supports it. Then I discovered that
722 you can have some filesystems that support ftruncate
723 expansion and some that don't! On Linux fat can't do
724 ftruncate extend but ext2 can. */
725
726 result = sys_ftruncate(fd, len);
727 if (result == 0)
728 goto done;
729
730 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
731 extend a file with ftruncate. Provide alternate implementation
732 for this */
733 currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
734 if (currpos == -1) {
735 goto done;
736 }
737
738 /* Do an fstat to see if the file is longer than the requested
739 size in which case the ftruncate above should have
740 succeeded or shorter, in which case seek to len - 1 and
741 write 1 byte of zero */
742 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
743 goto done;
744 }
745
746#ifdef S_ISFIFO
747 if (S_ISFIFO(st.st_mode)) {
748 result = 0;
749 goto done;
750 }
751#endif
752
753 if (st.st_size == len) {
754 result = 0;
755 goto done;
756 }
757
758 if (st.st_size > len) {
759 /* the sys_ftruncate should have worked */
760 goto done;
761 }
762
763 if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
764 goto done;
765
766 if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
767 goto done;
768
769 /* Seek to where we were */
770 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
771 goto done;
772 result = 0;
773
774 done:
775
776 END_PROFILE(syscall_ftruncate);
777 return result;
778}
779
780static BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
781{
782 BOOL result;
783
784 START_PROFILE(syscall_fcntl_lock);
785 result = fcntl_lock(fd, op, offset, count, type);
786 END_PROFILE(syscall_fcntl_lock);
787 return result;
788}
789
790static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, int fd,
791 uint32 share_mode)
792{
793 START_PROFILE(syscall_kernel_flock);
794 kernel_flock(fd, share_mode);
795 END_PROFILE(syscall_kernel_flock);
796 return 0;
797}
798
799static 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)
800{
801 BOOL result;
802
803 START_PROFILE(syscall_fcntl_getlock);
804 result = fcntl_getlock(fd, poffset, pcount, ptype, ppid);
805 END_PROFILE(syscall_fcntl_getlock);
806 return result;
807}
808
809static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp, int fd,
810 int leasetype)
811{
812 int result = -1;
813
814 START_PROFILE(syscall_linux_setlease);
815
816#ifdef LINUX
817 /* first set the signal handler */
818 if(linux_set_lease_sighandler(fd) == -1)
819 return -1;
820
821 result = linux_setlease(fd, leasetype);
822#else
823 errno = ENOSYS;
824#endif
825 END_PROFILE(syscall_linux_setlease);
826 return result;
827}
828
829static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
830{
831 int result;
832
833 START_PROFILE(syscall_symlink);
834 result = sys_symlink(oldpath, newpath);
835 END_PROFILE(syscall_symlink);
836 return result;
837}
838
839static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
840{
841 int result;
842
843 START_PROFILE(syscall_readlink);
844 result = sys_readlink(path, buf, bufsiz);
845 END_PROFILE(syscall_readlink);
846 return result;
847}
848
849static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
850{
851 int result;
852
853 START_PROFILE(syscall_link);
854 result = sys_link(oldpath, newpath);
855 END_PROFILE(syscall_link);
856 return result;
857}
858
859static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
860{
861 int result;
862
863 START_PROFILE(syscall_mknod);
864 result = sys_mknod(pathname, mode, dev);
865 END_PROFILE(syscall_mknod);
866 return result;
867}
868
869static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
870{
871 char *result;
872
873 START_PROFILE(syscall_realpath);
874 result = sys_realpath(path, resolved_path);
875 END_PROFILE(syscall_realpath);
876 return result;
877}
878
879static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
880 struct sys_notify_context *ctx,
881 struct notify_entry *e,
882 void (*callback)(struct sys_notify_context *ctx,
883 void *private_data,
884 struct notify_event *ev),
885 void *private_data, void *handle)
886{
887 /*
888 * So far inotify is the only supported default notify mechanism. If
889 * another platform like the the BSD's or a proprietary Unix comes
890 * along and wants another default, we can play the same trick we
891 * played with Posix ACLs.
892 *
893 * Until that is the case, hard-code inotify here.
894 */
895#ifdef HAVE_INOTIFY
896 if (lp_kernel_change_notify(ctx->conn->params)) {
897 return inotify_watch(ctx, e, callback, private_data, handle);
898 }
899#endif
900 /*
901 * Do nothing, leave everything to notify_internal.c
902 */
903 return NT_STATUS_OK;
904}
905
906static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
907{
908#ifdef HAVE_CHFLAGS
909 return chflags(path, flags);
910#else
911 errno = ENOSYS;
912 return -1;
913#endif
914}
915
916static size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info, SEC_DESC **ppdesc)
917{
918 size_t result;
919
920 START_PROFILE(fget_nt_acl);
921 result = get_nt_acl(fsp, security_info, ppdesc);
922 END_PROFILE(fget_nt_acl);
923 return result;
924}
925
926static size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info, SEC_DESC **ppdesc)
927{
928 size_t result;
929
930 START_PROFILE(get_nt_acl);
931 result = get_nt_acl(fsp, security_info, ppdesc);
932 END_PROFILE(get_nt_acl);
933 return result;
934}
935
936static BOOL vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
937{
938 BOOL result;
939
940 START_PROFILE(fset_nt_acl);
941 result = set_nt_acl(fsp, security_info_sent, psd);
942 END_PROFILE(fset_nt_acl);
943 return result;
944}
945
946static BOOL vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
947{
948 BOOL result;
949
950 START_PROFILE(set_nt_acl);
951 result = set_nt_acl(fsp, security_info_sent, psd);
952 END_PROFILE(set_nt_acl);
953 return result;
954}
955
956static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
957{
958#ifdef HAVE_NO_ACL
959 errno = ENOSYS;
960 return -1;
961#else
962 int result;
963
964 START_PROFILE(chmod_acl);
965 result = chmod_acl(handle->conn, name, mode);
966 END_PROFILE(chmod_acl);
967 return result;
968#endif
969}
970
971static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
972{
973#ifdef HAVE_NO_ACL
974 errno = ENOSYS;
975 return -1;
976#else
977 int result;
978
979 START_PROFILE(fchmod_acl);
980 result = fchmod_acl(fsp, fd, mode);
981 END_PROFILE(fchmod_acl);
982 return result;
983#endif
984}
985
986static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
987{
988 return sys_acl_get_entry(theacl, entry_id, entry_p);
989}
990
991static int vfswrap_sys_acl_get_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
992{
993 return sys_acl_get_tag_type(entry_d, tag_type_p);
994}
995
996static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
997{
998 return sys_acl_get_permset(entry_d, permset_p);
999}
1000
1001static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1002{
1003 return sys_acl_get_qualifier(entry_d);
1004}
1005
1006static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1007{
1008 return sys_acl_get_file(handle, path_p, type);
1009}
1010
1011static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
1012{
1013 return sys_acl_get_fd(handle, fsp, fd);
1014}
1015
1016static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1017{
1018 return sys_acl_clear_perms(permset);
1019}
1020
1021static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1022{
1023 return sys_acl_add_perm(permset, perm);
1024}
1025
1026static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1027{
1028 return sys_acl_to_text(theacl, plen);
1029}
1030
1031static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1032{
1033 return sys_acl_init(count);
1034}
1035
1036static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1037{
1038 return sys_acl_create_entry(pacl, pentry);
1039}
1040
1041static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1042{
1043 return sys_acl_set_tag_type(entry, tagtype);
1044}
1045
1046static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1047{
1048 return sys_acl_set_qualifier(entry, qual);
1049}
1050
1051static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1052{
1053 return sys_acl_set_permset(entry, permset);
1054}
1055
1056static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1057{
1058 return sys_acl_valid(theacl );
1059}
1060
1061static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1062{
1063 return sys_acl_set_file(handle, name, acltype, theacl);
1064}
1065
1066static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
1067{
1068 return sys_acl_set_fd(handle, fsp, fd, theacl);
1069}
1070
1071static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1072{
1073 return sys_acl_delete_def_file(handle, path);
1074}
1075
1076static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1077{
1078 return sys_acl_get_perm(permset, perm);
1079}
1080
1081static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1082{
1083 return sys_acl_free_text(text);
1084}
1085
1086static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1087{
1088 return sys_acl_free_acl(posix_acl);
1089}
1090
1091static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1092{
1093 return sys_acl_free_qualifier(qualifier, tagtype);
1094}
1095
1096/****************************************************************
1097 Extended attribute operations.
1098*****************************************************************/
1099
1100static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1101{
1102 return sys_getxattr(path, name, value, size);
1103}
1104
1105static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1106{
1107 return sys_lgetxattr(path, name, value, size);
1108}
1109
1110static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, void *value, size_t size)
1111{
1112 return sys_fgetxattr(fd, name, value, size);
1113}
1114
1115static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1116{
1117 return sys_listxattr(path, list, size);
1118}
1119
1120ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1121{
1122 return sys_llistxattr(path, list, size);
1123}
1124
1125ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, char *list, size_t size)
1126{
1127 return sys_flistxattr(fd, list, size);
1128}
1129
1130static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1131{
1132 return sys_removexattr(path, name);
1133}
1134
1135static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1136{
1137 return sys_lremovexattr(path, name);
1138}
1139
1140static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name)
1141{
1142 return sys_fremovexattr(fd, name);
1143}
1144
1145static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1146{
1147 return sys_setxattr(path, name, value, size, flags);
1148}
1149
1150static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1151{
1152 return sys_lsetxattr(path, name, value, size, flags);
1153}
1154
1155static 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)
1156{
1157 return sys_fsetxattr(fd, name, value, size, flags);
1158}
1159
1160static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1161{
1162 return sys_aio_read(aiocb);
1163}
1164
1165static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1166{
1167 return sys_aio_write(aiocb);
1168}
1169
1170static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1171{
1172 return sys_aio_return(aiocb);
1173}
1174
1175static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_AIOCB *aiocb)
1176{
1177 return sys_aio_cancel(fd, aiocb);
1178}
1179
1180static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1181{
1182 return sys_aio_error(aiocb);
1183}
1184
1185static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1186{
1187 return sys_aio_fsync(op, aiocb);
1188}
1189
1190static 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)
1191{
1192 return sys_aio_suspend(aiocb, n, timeout);
1193}
1194
1195static vfs_op_tuple vfs_default_ops[] = {
1196
1197 /* Disk operations */
1198
1199 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1200 SMB_VFS_LAYER_OPAQUE},
1201 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1202 SMB_VFS_LAYER_OPAQUE},
1203 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1204 SMB_VFS_LAYER_OPAQUE},
1205 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1206 SMB_VFS_LAYER_OPAQUE},
1207 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1208 SMB_VFS_LAYER_OPAQUE},
1209 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1210 SMB_VFS_LAYER_OPAQUE},
1211 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1212 SMB_VFS_LAYER_OPAQUE},
1213
1214 /* Directory operations */
1215
1216 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1217 SMB_VFS_LAYER_OPAQUE},
1218 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1219 SMB_VFS_LAYER_OPAQUE},
1220 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1221 SMB_VFS_LAYER_OPAQUE},
1222 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1223 SMB_VFS_LAYER_OPAQUE},
1224 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1225 SMB_VFS_LAYER_OPAQUE},
1226 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1227 SMB_VFS_LAYER_OPAQUE},
1228 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1229 SMB_VFS_LAYER_OPAQUE},
1230 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1231 SMB_VFS_LAYER_OPAQUE},
1232
1233 /* File operations */
1234
1235 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1236 SMB_VFS_LAYER_OPAQUE},
1237 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1238 SMB_VFS_LAYER_OPAQUE},
1239 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1240 SMB_VFS_LAYER_OPAQUE},
1241 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1242 SMB_VFS_LAYER_OPAQUE},
1243 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1244 SMB_VFS_LAYER_OPAQUE},
1245 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1246 SMB_VFS_LAYER_OPAQUE},
1247 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1248 SMB_VFS_LAYER_OPAQUE},
1249 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1250 SMB_VFS_LAYER_OPAQUE},
1251 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1252 SMB_VFS_LAYER_OPAQUE},
1253 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1254 SMB_VFS_LAYER_OPAQUE},
1255 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1256 SMB_VFS_LAYER_OPAQUE},
1257 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1258 SMB_VFS_LAYER_OPAQUE},
1259 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1260 SMB_VFS_LAYER_OPAQUE},
1261 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1262 SMB_VFS_LAYER_OPAQUE},
1263 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1264 SMB_VFS_LAYER_OPAQUE},
1265 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1266 SMB_VFS_LAYER_OPAQUE},
1267 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1268 SMB_VFS_LAYER_OPAQUE},
1269 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1270 SMB_VFS_LAYER_OPAQUE},
1271 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1272 SMB_VFS_LAYER_OPAQUE},
1273 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1274 SMB_VFS_LAYER_OPAQUE},
1275 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1276 SMB_VFS_LAYER_OPAQUE},
1277 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1278 SMB_VFS_LAYER_OPAQUE},
1279 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1280 SMB_VFS_LAYER_OPAQUE},
1281 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1282 SMB_VFS_LAYER_OPAQUE},
1283 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1284 SMB_VFS_LAYER_OPAQUE},
1285 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1286 SMB_VFS_LAYER_OPAQUE},
1287 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1288 SMB_VFS_LAYER_OPAQUE},
1289 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1290 SMB_VFS_LAYER_OPAQUE},
1291 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1292 SMB_VFS_LAYER_OPAQUE},
1293 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1294 SMB_VFS_LAYER_OPAQUE},
1295 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1296 SMB_VFS_LAYER_OPAQUE},
1297 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1298 SMB_VFS_LAYER_OPAQUE},
1299 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1300 SMB_VFS_LAYER_OPAQUE},
1301
1302 /* NT ACL operations. */
1303
1304 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1305 SMB_VFS_LAYER_OPAQUE},
1306 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1307 SMB_VFS_LAYER_OPAQUE},
1308 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1309 SMB_VFS_LAYER_OPAQUE},
1310 {SMB_VFS_OP(vfswrap_set_nt_acl), SMB_VFS_OP_SET_NT_ACL,
1311 SMB_VFS_LAYER_OPAQUE},
1312
1313 /* POSIX ACL operations. */
1314
1315 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1316 SMB_VFS_LAYER_OPAQUE},
1317 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1318 SMB_VFS_LAYER_OPAQUE},
1319 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1320 SMB_VFS_LAYER_OPAQUE},
1321 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1322 SMB_VFS_LAYER_OPAQUE},
1323 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1324 SMB_VFS_LAYER_OPAQUE},
1325 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1326 SMB_VFS_LAYER_OPAQUE},
1327 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1328 SMB_VFS_LAYER_OPAQUE},
1329 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1330 SMB_VFS_LAYER_OPAQUE},
1331 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1332 SMB_VFS_LAYER_OPAQUE},
1333 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1334 SMB_VFS_LAYER_OPAQUE},
1335 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1336 SMB_VFS_LAYER_OPAQUE},
1337 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1338 SMB_VFS_LAYER_OPAQUE},
1339 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1340 SMB_VFS_LAYER_OPAQUE},
1341 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1342 SMB_VFS_LAYER_OPAQUE},
1343 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1344 SMB_VFS_LAYER_OPAQUE},
1345 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1346 SMB_VFS_LAYER_OPAQUE},
1347 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1348 SMB_VFS_LAYER_OPAQUE},
1349 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1350 SMB_VFS_LAYER_OPAQUE},
1351 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1352 SMB_VFS_LAYER_OPAQUE},
1353 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1354 SMB_VFS_LAYER_OPAQUE},
1355 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1356 SMB_VFS_LAYER_OPAQUE},
1357 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1358 SMB_VFS_LAYER_OPAQUE},
1359 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1360 SMB_VFS_LAYER_OPAQUE},
1361 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1362 SMB_VFS_LAYER_OPAQUE},
1363
1364 /* EA operations. */
1365
1366 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1367 SMB_VFS_LAYER_OPAQUE},
1368 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1369 SMB_VFS_LAYER_OPAQUE},
1370 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1371 SMB_VFS_LAYER_OPAQUE},
1372 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1373 SMB_VFS_LAYER_OPAQUE},
1374 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1375 SMB_VFS_LAYER_OPAQUE},
1376 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1377 SMB_VFS_LAYER_OPAQUE},
1378 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1379 SMB_VFS_LAYER_OPAQUE},
1380 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1381 SMB_VFS_LAYER_OPAQUE},
1382 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1383 SMB_VFS_LAYER_OPAQUE},
1384 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1385 SMB_VFS_LAYER_OPAQUE},
1386 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1387 SMB_VFS_LAYER_OPAQUE},
1388 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1389 SMB_VFS_LAYER_OPAQUE},
1390
1391 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1392 SMB_VFS_LAYER_OPAQUE},
1393 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1394 SMB_VFS_LAYER_OPAQUE},
1395 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1396 SMB_VFS_LAYER_OPAQUE},
1397 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1398 SMB_VFS_LAYER_OPAQUE},
1399 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1400 SMB_VFS_LAYER_OPAQUE},
1401 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1402 SMB_VFS_LAYER_OPAQUE},
1403 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1404 SMB_VFS_LAYER_OPAQUE},
1405
1406 /* Finish VFS operations definition */
1407
1408 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1409 SMB_VFS_LAYER_NOOP}
1410};
1411
1412NTSTATUS vfs_default_init(void);
1413NTSTATUS vfs_default_init(void)
1414{
1415 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1416
1417 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1418 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1419 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1420 smb_panic("operation(s) missing from default VFS module");
1421 }
1422
1423 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1424 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1425}
Note: See TracBrowser for help on using the repository browser.