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

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

Update 3.3 to 3.3.9
File size: 43.5 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 if (lp_posix_pathnames()) {
997 ret = SMB_VFS_LSTAT(handle->conn, fname, &sbuf);
998 } else {
999 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
1000 }
1001 }
1002
1003 if (ret == -1) {
1004 return map_nt_error_from_unix(errno);
1005 }
1006
1007 if (S_ISDIR(sbuf.st_mode)) {
1008 goto done;
1009 }
1010
1011 streams = talloc(mem_ctx, struct stream_struct);
1012
1013 if (streams == NULL) {
1014 return NT_STATUS_NO_MEMORY;
1015 }
1016
1017 streams->size = sbuf.st_size;
1018 streams->alloc_size = get_allocation_size(handle->conn, fsp, &sbuf);
1019
1020 streams->name = talloc_strdup(streams, "::$DATA");
1021 if (streams->name == NULL) {
1022 TALLOC_FREE(streams);
1023 return NT_STATUS_NO_MEMORY;
1024 }
1025
1026 num_streams = 1;
1027 done:
1028 *pnum_streams = num_streams;
1029 *pstreams = streams;
1030 return NT_STATUS_OK;
1031}
1032
1033static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1034 const char *path,
1035 const char *name,
1036 TALLOC_CTX *mem_ctx,
1037 char **found_name)
1038{
1039 return get_real_filename(handle->conn, path, name, mem_ctx,
1040 found_name);
1041}
1042
1043static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1044 files_struct *fsp,
1045 uint32 security_info, SEC_DESC **ppdesc)
1046{
1047 NTSTATUS result;
1048
1049 START_PROFILE(fget_nt_acl);
1050 result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1051 END_PROFILE(fget_nt_acl);
1052 return result;
1053}
1054
1055static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1056 const char *name,
1057 uint32 security_info, SEC_DESC **ppdesc)
1058{
1059 NTSTATUS result;
1060
1061 START_PROFILE(get_nt_acl);
1062 result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1063 END_PROFILE(get_nt_acl);
1064 return result;
1065}
1066
1067static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1068{
1069 NTSTATUS result;
1070
1071 START_PROFILE(fset_nt_acl);
1072 result = set_nt_acl(fsp, security_info_sent, psd);
1073 END_PROFILE(fset_nt_acl);
1074 return result;
1075}
1076
1077static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
1078{
1079#ifdef HAVE_NO_ACL
1080 errno = ENOSYS;
1081 return -1;
1082#else
1083 int result;
1084
1085 START_PROFILE(chmod_acl);
1086 result = chmod_acl(handle->conn, name, mode);
1087 END_PROFILE(chmod_acl);
1088 return result;
1089#endif
1090}
1091
1092static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1093{
1094#ifdef HAVE_NO_ACL
1095 errno = ENOSYS;
1096 return -1;
1097#else
1098 int result;
1099
1100 START_PROFILE(fchmod_acl);
1101 result = fchmod_acl(fsp, mode);
1102 END_PROFILE(fchmod_acl);
1103 return result;
1104#endif
1105}
1106
1107static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1108{
1109 return sys_acl_get_entry(theacl, entry_id, entry_p);
1110}
1111
1112static int vfswrap_sys_acl_get_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
1113{
1114 return sys_acl_get_tag_type(entry_d, tag_type_p);
1115}
1116
1117static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1118{
1119 return sys_acl_get_permset(entry_d, permset_p);
1120}
1121
1122static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1123{
1124 return sys_acl_get_qualifier(entry_d);
1125}
1126
1127static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1128{
1129 return sys_acl_get_file(handle, path_p, type);
1130}
1131
1132static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1133{
1134 return sys_acl_get_fd(handle, fsp);
1135}
1136
1137static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1138{
1139 return sys_acl_clear_perms(permset);
1140}
1141
1142static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1143{
1144 return sys_acl_add_perm(permset, perm);
1145}
1146
1147static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1148{
1149 return sys_acl_to_text(theacl, plen);
1150}
1151
1152static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1153{
1154 return sys_acl_init(count);
1155}
1156
1157static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1158{
1159 return sys_acl_create_entry(pacl, pentry);
1160}
1161
1162static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1163{
1164 return sys_acl_set_tag_type(entry, tagtype);
1165}
1166
1167static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1168{
1169 return sys_acl_set_qualifier(entry, qual);
1170}
1171
1172static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1173{
1174 return sys_acl_set_permset(entry, permset);
1175}
1176
1177static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1178{
1179 return sys_acl_valid(theacl );
1180}
1181
1182static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1183{
1184 return sys_acl_set_file(handle, name, acltype, theacl);
1185}
1186
1187static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1188{
1189 return sys_acl_set_fd(handle, fsp, theacl);
1190}
1191
1192static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1193{
1194 return sys_acl_delete_def_file(handle, path);
1195}
1196
1197static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1198{
1199 return sys_acl_get_perm(permset, perm);
1200}
1201
1202static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1203{
1204 return sys_acl_free_text(text);
1205}
1206
1207static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1208{
1209 return sys_acl_free_acl(posix_acl);
1210}
1211
1212static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1213{
1214 return sys_acl_free_qualifier(qualifier, tagtype);
1215}
1216
1217/****************************************************************
1218 Extended attribute operations.
1219*****************************************************************/
1220
1221static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1222{
1223 return sys_getxattr(path, name, value, size);
1224}
1225
1226static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1227{
1228 return sys_lgetxattr(path, name, value, size);
1229}
1230
1231static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1232{
1233 return sys_fgetxattr(fsp->fh->fd, name, value, size);
1234}
1235
1236static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1237{
1238 return sys_listxattr(path, list, size);
1239}
1240
1241ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1242{
1243 return sys_llistxattr(path, list, size);
1244}
1245
1246ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1247{
1248 return sys_flistxattr(fsp->fh->fd, list, size);
1249}
1250
1251static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1252{
1253 return sys_removexattr(path, name);
1254}
1255
1256static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1257{
1258 return sys_lremovexattr(path, name);
1259}
1260
1261static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1262{
1263 return sys_fremovexattr(fsp->fh->fd, name);
1264}
1265
1266static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1267{
1268 return sys_setxattr(path, name, value, size, flags);
1269}
1270
1271static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1272{
1273 return sys_lsetxattr(path, name, value, size, flags);
1274}
1275
1276static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1277{
1278 return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1279}
1280
1281static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1282{
1283 return sys_aio_read(aiocb);
1284}
1285
1286static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1287{
1288 return sys_aio_write(aiocb);
1289}
1290
1291static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1292{
1293 return sys_aio_return(aiocb);
1294}
1295
1296static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1297{
1298 return sys_aio_cancel(fsp->fh->fd, aiocb);
1299}
1300
1301static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1302{
1303 return sys_aio_error(aiocb);
1304}
1305
1306static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1307{
1308 return sys_aio_fsync(op, aiocb);
1309}
1310
1311static 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)
1312{
1313 return sys_aio_suspend(aiocb, n, timeout);
1314}
1315
1316static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1317{
1318 return false;
1319}
1320
1321static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1322{
1323 if (ISDOT(path) || ISDOTDOT(path)) {
1324 return false;
1325 }
1326
1327 if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1328#if defined(ENOTSUP)
1329 errno = ENOTSUP;
1330#endif
1331 return false;
1332 }
1333
1334 return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1335}
1336
1337static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1338{
1339 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1340#if defined(ENOTSUP)
1341 errno = ENOTSUP;
1342#endif
1343 return -1;
1344}
1345
1346static vfs_op_tuple vfs_default_ops[] = {
1347
1348 /* Disk operations */
1349
1350 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1351 SMB_VFS_LAYER_OPAQUE},
1352 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1353 SMB_VFS_LAYER_OPAQUE},
1354 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1355 SMB_VFS_LAYER_OPAQUE},
1356 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1357 SMB_VFS_LAYER_OPAQUE},
1358 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1359 SMB_VFS_LAYER_OPAQUE},
1360 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1361 SMB_VFS_LAYER_OPAQUE},
1362 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1363 SMB_VFS_LAYER_OPAQUE},
1364 {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1365 SMB_VFS_LAYER_OPAQUE},
1366
1367 /* Directory operations */
1368
1369 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1370 SMB_VFS_LAYER_OPAQUE},
1371 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1372 SMB_VFS_LAYER_OPAQUE},
1373 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1374 SMB_VFS_LAYER_OPAQUE},
1375 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1376 SMB_VFS_LAYER_OPAQUE},
1377 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1378 SMB_VFS_LAYER_OPAQUE},
1379 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1380 SMB_VFS_LAYER_OPAQUE},
1381 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1382 SMB_VFS_LAYER_OPAQUE},
1383 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1384 SMB_VFS_LAYER_OPAQUE},
1385
1386 /* File operations */
1387
1388 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1389 SMB_VFS_LAYER_OPAQUE},
1390 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1391 SMB_VFS_LAYER_OPAQUE},
1392 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1393 SMB_VFS_LAYER_OPAQUE},
1394 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1395 SMB_VFS_LAYER_OPAQUE},
1396 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1397 SMB_VFS_LAYER_OPAQUE},
1398 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1399 SMB_VFS_LAYER_OPAQUE},
1400 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1401 SMB_VFS_LAYER_OPAQUE},
1402 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1403 SMB_VFS_LAYER_OPAQUE},
1404 {SMB_VFS_OP(vfswrap_recvfile), SMB_VFS_OP_RECVFILE,
1405 SMB_VFS_LAYER_OPAQUE},
1406 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1407 SMB_VFS_LAYER_OPAQUE},
1408 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1409 SMB_VFS_LAYER_OPAQUE},
1410 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1411 SMB_VFS_LAYER_OPAQUE},
1412 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1413 SMB_VFS_LAYER_OPAQUE},
1414 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1415 SMB_VFS_LAYER_OPAQUE},
1416 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1417 SMB_VFS_LAYER_OPAQUE},
1418 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1419 SMB_VFS_LAYER_OPAQUE},
1420 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1421 SMB_VFS_LAYER_OPAQUE},
1422 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1423 SMB_VFS_LAYER_OPAQUE},
1424 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1425 SMB_VFS_LAYER_OPAQUE},
1426 {SMB_VFS_OP(vfswrap_lchown), SMB_VFS_OP_LCHOWN,
1427 SMB_VFS_LAYER_OPAQUE},
1428 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1429 SMB_VFS_LAYER_OPAQUE},
1430 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1431 SMB_VFS_LAYER_OPAQUE},
1432 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1433 SMB_VFS_LAYER_OPAQUE},
1434 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1435 SMB_VFS_LAYER_OPAQUE},
1436 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1437 SMB_VFS_LAYER_OPAQUE},
1438 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1439 SMB_VFS_LAYER_OPAQUE},
1440 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1441 SMB_VFS_LAYER_OPAQUE},
1442 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1443 SMB_VFS_LAYER_OPAQUE},
1444 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1445 SMB_VFS_LAYER_OPAQUE},
1446 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1447 SMB_VFS_LAYER_OPAQUE},
1448 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1449 SMB_VFS_LAYER_OPAQUE},
1450 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1451 SMB_VFS_LAYER_OPAQUE},
1452 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1453 SMB_VFS_LAYER_OPAQUE},
1454 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1455 SMB_VFS_LAYER_OPAQUE},
1456 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1457 SMB_VFS_LAYER_OPAQUE},
1458 {SMB_VFS_OP(vfswrap_file_id_create), SMB_VFS_OP_FILE_ID_CREATE,
1459 SMB_VFS_LAYER_OPAQUE},
1460 {SMB_VFS_OP(vfswrap_streaminfo), SMB_VFS_OP_STREAMINFO,
1461 SMB_VFS_LAYER_OPAQUE},
1462 {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1463 SMB_VFS_LAYER_OPAQUE},
1464
1465 /* NT ACL operations. */
1466
1467 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1468 SMB_VFS_LAYER_OPAQUE},
1469 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1470 SMB_VFS_LAYER_OPAQUE},
1471 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1472 SMB_VFS_LAYER_OPAQUE},
1473
1474 /* POSIX ACL operations. */
1475
1476 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1477 SMB_VFS_LAYER_OPAQUE},
1478 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1479 SMB_VFS_LAYER_OPAQUE},
1480 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1481 SMB_VFS_LAYER_OPAQUE},
1482 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1483 SMB_VFS_LAYER_OPAQUE},
1484 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1485 SMB_VFS_LAYER_OPAQUE},
1486 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1487 SMB_VFS_LAYER_OPAQUE},
1488 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1489 SMB_VFS_LAYER_OPAQUE},
1490 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1491 SMB_VFS_LAYER_OPAQUE},
1492 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1493 SMB_VFS_LAYER_OPAQUE},
1494 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1495 SMB_VFS_LAYER_OPAQUE},
1496 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1497 SMB_VFS_LAYER_OPAQUE},
1498 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1499 SMB_VFS_LAYER_OPAQUE},
1500 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1501 SMB_VFS_LAYER_OPAQUE},
1502 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1503 SMB_VFS_LAYER_OPAQUE},
1504 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1505 SMB_VFS_LAYER_OPAQUE},
1506 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1507 SMB_VFS_LAYER_OPAQUE},
1508 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1509 SMB_VFS_LAYER_OPAQUE},
1510 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1511 SMB_VFS_LAYER_OPAQUE},
1512 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1513 SMB_VFS_LAYER_OPAQUE},
1514 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1515 SMB_VFS_LAYER_OPAQUE},
1516 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1517 SMB_VFS_LAYER_OPAQUE},
1518 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1519 SMB_VFS_LAYER_OPAQUE},
1520 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1521 SMB_VFS_LAYER_OPAQUE},
1522 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1523 SMB_VFS_LAYER_OPAQUE},
1524
1525 /* EA operations. */
1526
1527 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1528 SMB_VFS_LAYER_OPAQUE},
1529 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1530 SMB_VFS_LAYER_OPAQUE},
1531 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1532 SMB_VFS_LAYER_OPAQUE},
1533 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1534 SMB_VFS_LAYER_OPAQUE},
1535 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1536 SMB_VFS_LAYER_OPAQUE},
1537 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1538 SMB_VFS_LAYER_OPAQUE},
1539 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1540 SMB_VFS_LAYER_OPAQUE},
1541 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1542 SMB_VFS_LAYER_OPAQUE},
1543 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1544 SMB_VFS_LAYER_OPAQUE},
1545 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1546 SMB_VFS_LAYER_OPAQUE},
1547 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1548 SMB_VFS_LAYER_OPAQUE},
1549 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1550 SMB_VFS_LAYER_OPAQUE},
1551
1552 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1553 SMB_VFS_LAYER_OPAQUE},
1554 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1555 SMB_VFS_LAYER_OPAQUE},
1556 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1557 SMB_VFS_LAYER_OPAQUE},
1558 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1559 SMB_VFS_LAYER_OPAQUE},
1560 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1561 SMB_VFS_LAYER_OPAQUE},
1562 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1563 SMB_VFS_LAYER_OPAQUE},
1564 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1565 SMB_VFS_LAYER_OPAQUE},
1566
1567 {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1568 SMB_VFS_LAYER_OPAQUE},
1569
1570 {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1571 SMB_VFS_LAYER_OPAQUE},
1572 {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1573 SMB_VFS_LAYER_OPAQUE},
1574
1575 /* Finish VFS operations definition */
1576
1577 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1578 SMB_VFS_LAYER_NOOP}
1579};
1580
1581NTSTATUS vfs_default_init(void);
1582NTSTATUS vfs_default_init(void)
1583{
1584 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1585
1586 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1587 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1588 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1589 smb_panic("operation(s) missing from default VFS module");
1590 }
1591
1592 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1593 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1594}
Note: See TracBrowser for help on using the repository browser.