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