source: branches/samba-3.2.x/source/modules/vfs_default.c

Last change on this file was 233, checked in by Herwig Bauernfeind, 16 years ago

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