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