s3: Modify SMB_VFS_FILE_ID_CREATE to take a stat struct
[samba.git] / source3 / modules / vfs_default.c
1 /*
2    Unix SMB/CIFS implementation.
3    Wrap disk only vfs functions to sidestep dodgy compilers.
4    Copyright (C) Tim Potter 1998
5    Copyright (C) Jeremy Allison 2007
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22
23 #undef DBGC_CLASS
24 #define DBGC_CLASS DBGC_VFS
25
26 /* Check for NULL pointer parameters in vfswrap_* functions */
27
28 /* We don't want to have NULL function pointers lying around.  Someone
29    is sure to try and execute them.  These stubs are used to prevent
30    this possibility. */
31
32 static int vfswrap_connect(vfs_handle_struct *handle,  const char *service, const char *user)
33 {
34     return 0;    /* Return >= 0 for success */
35 }
36
37 static void vfswrap_disconnect(vfs_handle_struct *handle)
38 {
39 }
40
41 /* Disk operations */
42
43 static 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
1057         return key;
1058 }
1059
1060 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1061                                    struct files_struct *fsp,
1062                                    const char *fname,
1063                                    TALLOC_CTX *mem_ctx,
1064                                    unsigned int *pnum_streams,
1065                                    struct stream_struct **pstreams)
1066 {
1067         SMB_STRUCT_STAT sbuf;
1068         unsigned int num_streams = 0;
1069         struct stream_struct *streams = NULL;
1070         int ret;
1071
1072         if ((fsp != NULL) && (fsp->is_directory)) {
1073                 /*
1074                  * No default streams on directories
1075                  */
1076                 goto done;
1077         }
1078
1079         if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1080                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1081         }
1082         else {
1083                 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
1084         }
1085
1086         if (ret == -1) {
1087                 return map_nt_error_from_unix(errno);
1088         }
1089
1090         if (S_ISDIR(sbuf.st_mode)) {
1091                 goto done;
1092         }
1093
1094         streams = talloc(mem_ctx, struct stream_struct);
1095
1096         if (streams == NULL) {
1097                 return NT_STATUS_NO_MEMORY;
1098         }
1099
1100         streams->size = sbuf.st_size;
1101         streams->alloc_size = SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp, &sbuf);
1102
1103         streams->name = talloc_strdup(streams, "::$DATA");
1104         if (streams->name == NULL) {
1105                 TALLOC_FREE(streams);
1106                 return NT_STATUS_NO_MEMORY;
1107         }
1108
1109         num_streams = 1;
1110  done:
1111         *pnum_streams = num_streams;
1112         *pstreams = streams;
1113         return NT_STATUS_OK;
1114 }
1115
1116 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1117                                      const char *path,
1118                                      const char *name,
1119                                      TALLOC_CTX *mem_ctx,
1120                                      char **found_name)
1121 {
1122         return get_real_filename(handle->conn, path, name, mem_ctx,
1123                                  found_name);
1124 }
1125
1126 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
1127                                          struct byte_range_lock *br_lck,
1128                                          struct lock_struct *plock,
1129                                          bool blocking_lock,
1130                                          struct blocking_lock_record *blr)
1131 {
1132         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1133
1134         /* Note: blr is not used in the default implementation. */
1135         return brl_lock_windows_default(br_lck, plock, blocking_lock);
1136 }
1137
1138 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
1139                                        struct messaging_context *msg_ctx,
1140                                        struct byte_range_lock *br_lck,
1141                                        const struct lock_struct *plock)
1142 {
1143         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1144
1145         return brl_unlock_windows_default(msg_ctx, br_lck, plock);
1146 }
1147
1148 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
1149                                        struct byte_range_lock *br_lck,
1150                                        struct lock_struct *plock,
1151                                        struct blocking_lock_record *blr)
1152 {
1153         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1154
1155         /* Note: blr is not used in the default implementation. */
1156         return brl_lock_cancel_default(br_lck, plock);
1157 }
1158
1159 /* NT ACL operations. */
1160
1161 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1162                                     files_struct *fsp,
1163                                     uint32 security_info, SEC_DESC **ppdesc)
1164 {
1165         NTSTATUS result;
1166
1167         START_PROFILE(fget_nt_acl);
1168         result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1169         END_PROFILE(fget_nt_acl);
1170         return result;
1171 }
1172
1173 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1174                                    const char *name,
1175                                    uint32 security_info, SEC_DESC **ppdesc)
1176 {
1177         NTSTATUS result;
1178
1179         START_PROFILE(get_nt_acl);
1180         result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1181         END_PROFILE(get_nt_acl);
1182         return result;
1183 }
1184
1185 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1186 {
1187         NTSTATUS result;
1188
1189         START_PROFILE(fset_nt_acl);
1190         result = set_nt_acl(fsp, security_info_sent, psd);
1191         END_PROFILE(fset_nt_acl);
1192         return result;
1193 }
1194
1195 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
1196 {
1197 #ifdef HAVE_NO_ACL
1198         errno = ENOSYS;
1199         return -1;
1200 #else
1201         int result;
1202
1203         START_PROFILE(chmod_acl);
1204         result = chmod_acl(handle->conn, name, mode);
1205         END_PROFILE(chmod_acl);
1206         return result;
1207 #endif
1208 }
1209
1210 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1211 {
1212 #ifdef HAVE_NO_ACL
1213         errno = ENOSYS;
1214         return -1;
1215 #else
1216         int result;
1217
1218         START_PROFILE(fchmod_acl);
1219         result = fchmod_acl(fsp, mode);
1220         END_PROFILE(fchmod_acl);
1221         return result;
1222 #endif
1223 }
1224
1225 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1226 {
1227         return sys_acl_get_entry(theacl, entry_id, entry_p);
1228 }
1229
1230 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)
1231 {
1232         return sys_acl_get_tag_type(entry_d, tag_type_p);
1233 }
1234
1235 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1236 {
1237         return sys_acl_get_permset(entry_d, permset_p);
1238 }
1239
1240 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
1241 {
1242         return sys_acl_get_qualifier(entry_d);
1243 }
1244
1245 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
1246 {
1247         return sys_acl_get_file(handle, path_p, type);
1248 }
1249
1250 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1251 {
1252         return sys_acl_get_fd(handle, fsp);
1253 }
1254
1255 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
1256 {
1257         return sys_acl_clear_perms(permset);
1258 }
1259
1260 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1261 {
1262         return sys_acl_add_perm(permset, perm);
1263 }
1264
1265 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
1266 {
1267         return sys_acl_to_text(theacl, plen);
1268 }
1269
1270 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle,  int count)
1271 {
1272         return sys_acl_init(count);
1273 }
1274
1275 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1276 {
1277         return sys_acl_create_entry(pacl, pentry);
1278 }
1279
1280 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1281 {
1282         return sys_acl_set_tag_type(entry, tagtype);
1283 }
1284
1285 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
1286 {
1287         return sys_acl_set_qualifier(entry, qual);
1288 }
1289
1290 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1291 {
1292         return sys_acl_set_permset(entry, permset);
1293 }
1294
1295 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
1296 {
1297         return sys_acl_valid(theacl );
1298 }
1299
1300 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1301 {
1302         return sys_acl_set_file(handle, name, acltype, theacl);
1303 }
1304
1305 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1306 {
1307         return sys_acl_set_fd(handle, fsp, theacl);
1308 }
1309
1310 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
1311 {
1312         return sys_acl_delete_def_file(handle, path);
1313 }
1314
1315 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1316 {
1317         return sys_acl_get_perm(permset, perm);
1318 }
1319
1320 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
1321 {
1322         return sys_acl_free_text(text);
1323 }
1324
1325 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
1326 {
1327         return sys_acl_free_acl(posix_acl);
1328 }
1329
1330 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
1331 {
1332         return sys_acl_free_qualifier(qualifier, tagtype);
1333 }
1334
1335 /****************************************************************
1336  Extended attribute operations.
1337 *****************************************************************/
1338
1339 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1340 {
1341         return sys_getxattr(path, name, value, size);
1342 }
1343
1344 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1345 {
1346         return sys_lgetxattr(path, name, value, size);
1347 }
1348
1349 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1350 {
1351         return sys_fgetxattr(fsp->fh->fd, name, value, size);
1352 }
1353
1354 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1355 {
1356         return sys_listxattr(path, list, size);
1357 }
1358
1359 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1360 {
1361         return sys_llistxattr(path, list, size);
1362 }
1363
1364 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1365 {
1366         return sys_flistxattr(fsp->fh->fd, list, size);
1367 }
1368
1369 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1370 {
1371         return sys_removexattr(path, name);
1372 }
1373
1374 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1375 {
1376         return sys_lremovexattr(path, name);
1377 }
1378
1379 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1380 {
1381         return sys_fremovexattr(fsp->fh->fd, name);
1382 }
1383
1384 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1385 {
1386         return sys_setxattr(path, name, value, size, flags);
1387 }
1388
1389 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1390 {
1391         return sys_lsetxattr(path, name, value, size, flags);
1392 }
1393
1394 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1395 {
1396         return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1397 }
1398
1399 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1400 {
1401         return sys_aio_read(aiocb);
1402 }
1403
1404 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1405 {
1406         return sys_aio_write(aiocb);
1407 }
1408
1409 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1410 {
1411         return sys_aio_return(aiocb);
1412 }
1413
1414 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1415 {
1416         return sys_aio_cancel(fsp->fh->fd, aiocb);
1417 }
1418
1419 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1420 {
1421         return sys_aio_error(aiocb);
1422 }
1423
1424 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1425 {
1426         return sys_aio_fsync(op, aiocb);
1427 }
1428
1429 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)
1430 {
1431         return sys_aio_suspend(aiocb, n, timeout);
1432 }
1433
1434 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1435 {
1436         return false;
1437 }
1438
1439 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1440 {
1441         if (ISDOT(path) || ISDOTDOT(path)) {
1442                 return false;
1443         }
1444
1445         if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1446 #if defined(ENOTSUP)
1447                 errno = ENOTSUP;
1448 #endif
1449                 return false;
1450         }
1451
1452         return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1453 }
1454
1455 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1456 {
1457         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1458 #if defined(ENOTSUP)
1459         errno = ENOTSUP;
1460 #endif
1461         return -1;
1462 }
1463
1464 static vfs_op_tuple vfs_default_ops[] = {
1465
1466         /* Disk operations */
1467
1468         {SMB_VFS_OP(vfswrap_connect),   SMB_VFS_OP_CONNECT,
1469          SMB_VFS_LAYER_OPAQUE},
1470         {SMB_VFS_OP(vfswrap_disconnect),        SMB_VFS_OP_DISCONNECT,
1471          SMB_VFS_LAYER_OPAQUE},
1472         {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1473          SMB_VFS_LAYER_OPAQUE},
1474         {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1475          SMB_VFS_LAYER_OPAQUE},
1476         {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1477          SMB_VFS_LAYER_OPAQUE},
1478         {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1479          SMB_VFS_LAYER_OPAQUE},
1480         {SMB_VFS_OP(vfswrap_statvfs),   SMB_VFS_OP_STATVFS,
1481          SMB_VFS_LAYER_OPAQUE},
1482         {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1483          SMB_VFS_LAYER_OPAQUE},
1484
1485         /* Directory operations */
1486
1487         {SMB_VFS_OP(vfswrap_opendir),   SMB_VFS_OP_OPENDIR,
1488          SMB_VFS_LAYER_OPAQUE},
1489         {SMB_VFS_OP(vfswrap_readdir),   SMB_VFS_OP_READDIR,
1490          SMB_VFS_LAYER_OPAQUE},
1491         {SMB_VFS_OP(vfswrap_seekdir),   SMB_VFS_OP_SEEKDIR,
1492          SMB_VFS_LAYER_OPAQUE},
1493         {SMB_VFS_OP(vfswrap_telldir),   SMB_VFS_OP_TELLDIR,
1494          SMB_VFS_LAYER_OPAQUE},
1495         {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1496          SMB_VFS_LAYER_OPAQUE},
1497         {SMB_VFS_OP(vfswrap_mkdir),     SMB_VFS_OP_MKDIR,
1498          SMB_VFS_LAYER_OPAQUE},
1499         {SMB_VFS_OP(vfswrap_rmdir),     SMB_VFS_OP_RMDIR,
1500          SMB_VFS_LAYER_OPAQUE},
1501         {SMB_VFS_OP(vfswrap_closedir),  SMB_VFS_OP_CLOSEDIR,
1502          SMB_VFS_LAYER_OPAQUE},
1503         {SMB_VFS_OP(vfswrap_init_search_op), SMB_VFS_OP_INIT_SEARCH_OP,
1504          SMB_VFS_LAYER_OPAQUE},
1505
1506         /* File operations */
1507
1508         {SMB_VFS_OP(vfswrap_open),      SMB_VFS_OP_OPEN,
1509          SMB_VFS_LAYER_OPAQUE},
1510         {SMB_VFS_OP(vfswrap_create_file),       SMB_VFS_OP_CREATE_FILE,
1511          SMB_VFS_LAYER_OPAQUE},
1512         {SMB_VFS_OP(vfswrap_close),     SMB_VFS_OP_CLOSE,
1513          SMB_VFS_LAYER_OPAQUE},
1514         {SMB_VFS_OP(vfswrap_read),      SMB_VFS_OP_READ,
1515          SMB_VFS_LAYER_OPAQUE},
1516         {SMB_VFS_OP(vfswrap_pread),     SMB_VFS_OP_PREAD,
1517          SMB_VFS_LAYER_OPAQUE},
1518         {SMB_VFS_OP(vfswrap_write),     SMB_VFS_OP_WRITE,
1519          SMB_VFS_LAYER_OPAQUE},
1520         {SMB_VFS_OP(vfswrap_pwrite),    SMB_VFS_OP_PWRITE,
1521          SMB_VFS_LAYER_OPAQUE},
1522         {SMB_VFS_OP(vfswrap_lseek),     SMB_VFS_OP_LSEEK,
1523          SMB_VFS_LAYER_OPAQUE},
1524         {SMB_VFS_OP(vfswrap_sendfile),  SMB_VFS_OP_SENDFILE,
1525          SMB_VFS_LAYER_OPAQUE},
1526         {SMB_VFS_OP(vfswrap_recvfile),  SMB_VFS_OP_RECVFILE,
1527          SMB_VFS_LAYER_OPAQUE},
1528         {SMB_VFS_OP(vfswrap_rename),    SMB_VFS_OP_RENAME,
1529          SMB_VFS_LAYER_OPAQUE},
1530         {SMB_VFS_OP(vfswrap_fsync),     SMB_VFS_OP_FSYNC,
1531          SMB_VFS_LAYER_OPAQUE},
1532         {SMB_VFS_OP(vfswrap_stat),      SMB_VFS_OP_STAT,
1533          SMB_VFS_LAYER_OPAQUE},
1534         {SMB_VFS_OP(vfswrap_fstat),     SMB_VFS_OP_FSTAT,
1535          SMB_VFS_LAYER_OPAQUE},
1536         {SMB_VFS_OP(vfswrap_lstat),     SMB_VFS_OP_LSTAT,
1537          SMB_VFS_LAYER_OPAQUE},
1538         {SMB_VFS_OP(vfswrap_get_alloc_size),    SMB_VFS_OP_GET_ALLOC_SIZE,
1539          SMB_VFS_LAYER_OPAQUE},
1540         {SMB_VFS_OP(vfswrap_unlink),    SMB_VFS_OP_UNLINK,
1541          SMB_VFS_LAYER_OPAQUE},
1542         {SMB_VFS_OP(vfswrap_chmod),     SMB_VFS_OP_CHMOD,
1543          SMB_VFS_LAYER_OPAQUE},
1544         {SMB_VFS_OP(vfswrap_fchmod),    SMB_VFS_OP_FCHMOD,
1545          SMB_VFS_LAYER_OPAQUE},
1546         {SMB_VFS_OP(vfswrap_chown),     SMB_VFS_OP_CHOWN,
1547          SMB_VFS_LAYER_OPAQUE},
1548         {SMB_VFS_OP(vfswrap_fchown),    SMB_VFS_OP_FCHOWN,
1549          SMB_VFS_LAYER_OPAQUE},
1550         {SMB_VFS_OP(vfswrap_lchown),    SMB_VFS_OP_LCHOWN,
1551          SMB_VFS_LAYER_OPAQUE},
1552         {SMB_VFS_OP(vfswrap_chdir),     SMB_VFS_OP_CHDIR,
1553          SMB_VFS_LAYER_OPAQUE},
1554         {SMB_VFS_OP(vfswrap_getwd),     SMB_VFS_OP_GETWD,
1555          SMB_VFS_LAYER_OPAQUE},
1556         {SMB_VFS_OP(vfswrap_ntimes),    SMB_VFS_OP_NTIMES,
1557          SMB_VFS_LAYER_OPAQUE},
1558         {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1559          SMB_VFS_LAYER_OPAQUE},
1560         {SMB_VFS_OP(vfswrap_lock),      SMB_VFS_OP_LOCK,
1561          SMB_VFS_LAYER_OPAQUE},
1562         {SMB_VFS_OP(vfswrap_kernel_flock),      SMB_VFS_OP_KERNEL_FLOCK,
1563          SMB_VFS_LAYER_OPAQUE},
1564         {SMB_VFS_OP(vfswrap_linux_setlease),    SMB_VFS_OP_LINUX_SETLEASE,
1565          SMB_VFS_LAYER_OPAQUE},
1566         {SMB_VFS_OP(vfswrap_getlock),   SMB_VFS_OP_GETLOCK,
1567          SMB_VFS_LAYER_OPAQUE},
1568         {SMB_VFS_OP(vfswrap_symlink),   SMB_VFS_OP_SYMLINK,
1569          SMB_VFS_LAYER_OPAQUE},
1570         {SMB_VFS_OP(vfswrap_readlink),  SMB_VFS_OP_READLINK,
1571          SMB_VFS_LAYER_OPAQUE},
1572         {SMB_VFS_OP(vfswrap_link),      SMB_VFS_OP_LINK,
1573          SMB_VFS_LAYER_OPAQUE},
1574         {SMB_VFS_OP(vfswrap_mknod),     SMB_VFS_OP_MKNOD,
1575          SMB_VFS_LAYER_OPAQUE},
1576         {SMB_VFS_OP(vfswrap_realpath),  SMB_VFS_OP_REALPATH,
1577          SMB_VFS_LAYER_OPAQUE},
1578         {SMB_VFS_OP(vfswrap_notify_watch),      SMB_VFS_OP_NOTIFY_WATCH,
1579          SMB_VFS_LAYER_OPAQUE},
1580         {SMB_VFS_OP(vfswrap_chflags),   SMB_VFS_OP_CHFLAGS,
1581          SMB_VFS_LAYER_OPAQUE},
1582         {SMB_VFS_OP(vfswrap_file_id_create),    SMB_VFS_OP_FILE_ID_CREATE,
1583          SMB_VFS_LAYER_OPAQUE},
1584         {SMB_VFS_OP(vfswrap_streaminfo),        SMB_VFS_OP_STREAMINFO,
1585          SMB_VFS_LAYER_OPAQUE},
1586         {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1587          SMB_VFS_LAYER_OPAQUE},
1588         {SMB_VFS_OP(vfswrap_brl_lock_windows),  SMB_VFS_OP_BRL_LOCK_WINDOWS,
1589          SMB_VFS_LAYER_OPAQUE},
1590         {SMB_VFS_OP(vfswrap_brl_unlock_windows),SMB_VFS_OP_BRL_UNLOCK_WINDOWS,
1591          SMB_VFS_LAYER_OPAQUE},
1592         {SMB_VFS_OP(vfswrap_brl_cancel_windows),SMB_VFS_OP_BRL_CANCEL_WINDOWS,
1593          SMB_VFS_LAYER_OPAQUE},
1594
1595         /* NT ACL operations. */
1596
1597         {SMB_VFS_OP(vfswrap_fget_nt_acl),       SMB_VFS_OP_FGET_NT_ACL,
1598          SMB_VFS_LAYER_OPAQUE},
1599         {SMB_VFS_OP(vfswrap_get_nt_acl),        SMB_VFS_OP_GET_NT_ACL,
1600          SMB_VFS_LAYER_OPAQUE},
1601         {SMB_VFS_OP(vfswrap_fset_nt_acl),       SMB_VFS_OP_FSET_NT_ACL,
1602          SMB_VFS_LAYER_OPAQUE},
1603
1604         /* POSIX ACL operations. */
1605
1606         {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1607          SMB_VFS_LAYER_OPAQUE},
1608         {SMB_VFS_OP(vfswrap_fchmod_acl),        SMB_VFS_OP_FCHMOD_ACL,
1609          SMB_VFS_LAYER_OPAQUE},
1610         {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1611          SMB_VFS_LAYER_OPAQUE},
1612         {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type),      SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1613          SMB_VFS_LAYER_OPAQUE},
1614         {SMB_VFS_OP(vfswrap_sys_acl_get_permset),       SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1615          SMB_VFS_LAYER_OPAQUE},
1616         {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier),     SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1617          SMB_VFS_LAYER_OPAQUE},
1618         {SMB_VFS_OP(vfswrap_sys_acl_get_file),  SMB_VFS_OP_SYS_ACL_GET_FILE,
1619          SMB_VFS_LAYER_OPAQUE},
1620         {SMB_VFS_OP(vfswrap_sys_acl_get_fd),    SMB_VFS_OP_SYS_ACL_GET_FD,
1621          SMB_VFS_LAYER_OPAQUE},
1622         {SMB_VFS_OP(vfswrap_sys_acl_clear_perms),       SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1623          SMB_VFS_LAYER_OPAQUE},
1624         {SMB_VFS_OP(vfswrap_sys_acl_add_perm),  SMB_VFS_OP_SYS_ACL_ADD_PERM,
1625          SMB_VFS_LAYER_OPAQUE},
1626         {SMB_VFS_OP(vfswrap_sys_acl_to_text),   SMB_VFS_OP_SYS_ACL_TO_TEXT,
1627          SMB_VFS_LAYER_OPAQUE},
1628         {SMB_VFS_OP(vfswrap_sys_acl_init),      SMB_VFS_OP_SYS_ACL_INIT,
1629          SMB_VFS_LAYER_OPAQUE},
1630         {SMB_VFS_OP(vfswrap_sys_acl_create_entry),      SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1631          SMB_VFS_LAYER_OPAQUE},
1632         {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type),      SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1633          SMB_VFS_LAYER_OPAQUE},
1634         {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier),     SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1635          SMB_VFS_LAYER_OPAQUE},
1636         {SMB_VFS_OP(vfswrap_sys_acl_set_permset),       SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1637          SMB_VFS_LAYER_OPAQUE},
1638         {SMB_VFS_OP(vfswrap_sys_acl_valid),     SMB_VFS_OP_SYS_ACL_VALID,
1639          SMB_VFS_LAYER_OPAQUE},
1640         {SMB_VFS_OP(vfswrap_sys_acl_set_file),  SMB_VFS_OP_SYS_ACL_SET_FILE,
1641          SMB_VFS_LAYER_OPAQUE},
1642         {SMB_VFS_OP(vfswrap_sys_acl_set_fd),    SMB_VFS_OP_SYS_ACL_SET_FD,
1643          SMB_VFS_LAYER_OPAQUE},
1644         {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file),   SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1645          SMB_VFS_LAYER_OPAQUE},
1646         {SMB_VFS_OP(vfswrap_sys_acl_get_perm),  SMB_VFS_OP_SYS_ACL_GET_PERM,
1647          SMB_VFS_LAYER_OPAQUE},
1648         {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1649          SMB_VFS_LAYER_OPAQUE},
1650         {SMB_VFS_OP(vfswrap_sys_acl_free_acl),  SMB_VFS_OP_SYS_ACL_FREE_ACL,
1651          SMB_VFS_LAYER_OPAQUE},
1652         {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier),    SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1653          SMB_VFS_LAYER_OPAQUE},
1654
1655         /* EA operations. */
1656
1657         {SMB_VFS_OP(vfswrap_getxattr),  SMB_VFS_OP_GETXATTR,
1658          SMB_VFS_LAYER_OPAQUE},
1659         {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1660          SMB_VFS_LAYER_OPAQUE},
1661         {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1662          SMB_VFS_LAYER_OPAQUE},
1663         {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1664          SMB_VFS_LAYER_OPAQUE},
1665         {SMB_VFS_OP(vfswrap_llistxattr),        SMB_VFS_OP_LLISTXATTR,
1666          SMB_VFS_LAYER_OPAQUE},
1667         {SMB_VFS_OP(vfswrap_flistxattr),        SMB_VFS_OP_FLISTXATTR,
1668          SMB_VFS_LAYER_OPAQUE},
1669         {SMB_VFS_OP(vfswrap_removexattr),       SMB_VFS_OP_REMOVEXATTR,
1670          SMB_VFS_LAYER_OPAQUE},
1671         {SMB_VFS_OP(vfswrap_lremovexattr),      SMB_VFS_OP_LREMOVEXATTR,
1672          SMB_VFS_LAYER_OPAQUE},
1673         {SMB_VFS_OP(vfswrap_fremovexattr),      SMB_VFS_OP_FREMOVEXATTR,
1674          SMB_VFS_LAYER_OPAQUE},
1675         {SMB_VFS_OP(vfswrap_setxattr),  SMB_VFS_OP_SETXATTR,
1676          SMB_VFS_LAYER_OPAQUE},
1677         {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1678          SMB_VFS_LAYER_OPAQUE},
1679         {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1680          SMB_VFS_LAYER_OPAQUE},
1681
1682         {SMB_VFS_OP(vfswrap_aio_read),  SMB_VFS_OP_AIO_READ,
1683          SMB_VFS_LAYER_OPAQUE},
1684         {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1685          SMB_VFS_LAYER_OPAQUE},
1686         {SMB_VFS_OP(vfswrap_aio_return),        SMB_VFS_OP_AIO_RETURN,
1687          SMB_VFS_LAYER_OPAQUE},
1688         {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1689          SMB_VFS_LAYER_OPAQUE},
1690         {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1691          SMB_VFS_LAYER_OPAQUE},
1692         {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1693          SMB_VFS_LAYER_OPAQUE},
1694         {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1695          SMB_VFS_LAYER_OPAQUE},
1696
1697         {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1698          SMB_VFS_LAYER_OPAQUE},
1699
1700         {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1701          SMB_VFS_LAYER_OPAQUE},
1702         {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1703          SMB_VFS_LAYER_OPAQUE},
1704
1705         /* Finish VFS operations definition */
1706
1707         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,
1708          SMB_VFS_LAYER_NOOP}
1709 };
1710
1711 NTSTATUS vfs_default_init(void);
1712 NTSTATUS vfs_default_init(void)
1713 {
1714         unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1715
1716         if (ARRAY_SIZE(vfs_default_ops) != needed) {
1717                 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1718                         DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1719                 smb_panic("operation(s) missing from default VFS module");
1720         }
1721
1722         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1723                                 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1724 }