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