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