2 * Skeleton VFS module. Implements passthrough operation of all VFS
3 * calls to disk functions.
5 * Copyright (C) Tim Potter, 1999-2000
6 * Copyright (C) Alexander Bokovoy, 2002
7 * Copyright (C) Stefan (metze) Metzmacher, 2003
8 * Copyright (C) Jeremy Allison 2009
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include "../source3/include/includes.h"
25 #include "lib/util/tevent_unix.h"
26 #include "lib/util/tevent_ntstatus.h"
28 /* PLEASE,PLEASE READ THE VFS MODULES CHAPTER OF THE
29 SAMBA DEVELOPERS GUIDE!!!!!!
32 /* If you take this file as template for your module
33 * please make sure that you remove all skel_XXX() functions you don't
34 * want to implement!! The passthrough operations are not
35 * necessary in a real module.
40 static int skel_connect(vfs_handle_struct
*handle
, const char *service
,
43 return SMB_VFS_NEXT_CONNECT(handle
, service
, user
);
46 static void skel_disconnect(vfs_handle_struct
*handle
)
48 SMB_VFS_NEXT_DISCONNECT(handle
);
51 static uint64_t skel_disk_free(vfs_handle_struct
*handle
,
52 const struct smb_filename
*smb_fname
,
57 return SMB_VFS_NEXT_DISK_FREE(handle
, smb_fname
, bsize
, dfree
, dsize
);
60 static int skel_get_quota(vfs_handle_struct
*handle
,
61 const struct smb_filename
*smb_fname
,
62 enum SMB_QUOTA_TYPE qtype
,
66 return SMB_VFS_NEXT_GET_QUOTA(handle
, smb_fname
, qtype
, id
, dq
);
69 static int skel_set_quota(vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
,
70 unid_t id
, SMB_DISK_QUOTA
*dq
)
72 return SMB_VFS_NEXT_SET_QUOTA(handle
, qtype
, id
, dq
);
75 static int skel_get_shadow_copy_data(vfs_handle_struct
*handle
,
77 struct shadow_copy_data
*shadow_copy_data
,
80 return SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle
, fsp
, shadow_copy_data
,
84 static int skel_statvfs(struct vfs_handle_struct
*handle
,
85 const struct smb_filename
*smb_fname
,
86 struct vfs_statvfs_struct
*statbuf
)
88 return SMB_VFS_NEXT_STATVFS(handle
, smb_fname
, statbuf
);
91 static uint32_t skel_fs_capabilities(struct vfs_handle_struct
*handle
,
92 enum timestamp_set_resolution
*p_ts_res
)
94 return SMB_VFS_NEXT_FS_CAPABILITIES(handle
, p_ts_res
);
97 static NTSTATUS
skel_get_dfs_referrals(struct vfs_handle_struct
*handle
,
98 struct dfs_GetDFSReferral
*r
)
100 return SMB_VFS_NEXT_GET_DFS_REFERRALS(handle
, r
);
103 static NTSTATUS
skel_create_dfs_pathat(struct vfs_handle_struct
*handle
,
104 struct files_struct
*dirfsp
,
105 const struct smb_filename
*smb_fname
,
106 const struct referral
*reflist
,
107 size_t referral_count
)
109 return SMB_VFS_NEXT_CREATE_DFS_PATHAT(handle
,
116 static NTSTATUS
skel_read_dfs_pathat(struct vfs_handle_struct
*handle
,
118 struct files_struct
*dirfsp
,
119 struct smb_filename
*smb_fname
,
120 struct referral
**ppreflist
,
121 size_t *preferral_count
)
123 return SMB_VFS_NEXT_READ_DFS_PATHAT(handle
,
131 static NTSTATUS
skel_snap_check_path(struct vfs_handle_struct
*handle
,
133 const char *service_path
,
136 return SMB_VFS_NEXT_SNAP_CHECK_PATH(handle
, mem_ctx
, service_path
,
140 static NTSTATUS
skel_snap_create(struct vfs_handle_struct
*handle
,
142 const char *base_volume
,
148 return SMB_VFS_NEXT_SNAP_CREATE(handle
, mem_ctx
, base_volume
, tstamp
,
149 rw
, base_path
, snap_path
);
152 static NTSTATUS
skel_snap_delete(struct vfs_handle_struct
*handle
,
157 return SMB_VFS_NEXT_SNAP_DELETE(handle
, mem_ctx
, base_path
, snap_path
);
160 static DIR *skel_fdopendir(vfs_handle_struct
*handle
, files_struct
*fsp
,
161 const char *mask
, uint32_t attr
)
163 return SMB_VFS_NEXT_FDOPENDIR(handle
, fsp
, mask
, attr
);
166 static struct dirent
*skel_readdir(vfs_handle_struct
*handle
,
167 struct files_struct
*dirfsp
,
169 SMB_STRUCT_STAT
*sbuf
)
171 return SMB_VFS_NEXT_READDIR(handle
, dirfsp
, dirp
, sbuf
);
174 static void skel_seekdir(vfs_handle_struct
*handle
, DIR *dirp
, long offset
)
176 SMB_VFS_NEXT_SEEKDIR(handle
, dirp
, offset
);
179 static long skel_telldir(vfs_handle_struct
*handle
, DIR *dirp
)
181 return SMB_VFS_NEXT_TELLDIR(handle
, dirp
);
184 static void skel_rewind_dir(vfs_handle_struct
*handle
, DIR *dirp
)
186 SMB_VFS_NEXT_REWINDDIR(handle
, dirp
);
189 static int skel_mkdirat(vfs_handle_struct
*handle
,
190 struct files_struct
*dirfsp
,
191 const struct smb_filename
*smb_fname
,
194 return SMB_VFS_NEXT_MKDIRAT(handle
,
200 static int skel_closedir(vfs_handle_struct
*handle
, DIR *dir
)
202 return SMB_VFS_NEXT_CLOSEDIR(handle
, dir
);
205 static int skel_openat(struct vfs_handle_struct
*handle
,
206 const struct files_struct
*dirfsp
,
207 const struct smb_filename
*smb_fname
,
208 struct files_struct
*fsp
,
209 const struct vfs_open_how
*how
)
211 return SMB_VFS_NEXT_OPENAT(handle
, dirfsp
, smb_fname
, fsp
, how
);
214 static NTSTATUS
skel_create_file(struct vfs_handle_struct
*handle
,
215 struct smb_request
*req
,
216 struct files_struct
*dirfsp
,
217 struct smb_filename
*smb_fname
,
218 uint32_t access_mask
,
219 uint32_t share_access
,
220 uint32_t create_disposition
,
221 uint32_t create_options
,
222 uint32_t file_attributes
,
223 uint32_t oplock_request
,
224 const struct smb2_lease
*lease
,
225 uint64_t allocation_size
,
226 uint32_t private_flags
,
227 struct security_descriptor
*sd
,
228 struct ea_list
*ea_list
,
229 files_struct
** result
, int *pinfo
,
230 const struct smb2_create_blobs
*in_context_blobs
,
231 struct smb2_create_blobs
*out_context_blobs
)
233 return SMB_VFS_NEXT_CREATE_FILE(handle
,
246 sd
, ea_list
, result
, pinfo
,
247 in_context_blobs
, out_context_blobs
);
250 static int skel_close_fn(vfs_handle_struct
*handle
, files_struct
*fsp
)
252 return SMB_VFS_NEXT_CLOSE(handle
, fsp
);
255 static ssize_t
skel_pread(vfs_handle_struct
*handle
, files_struct
*fsp
,
256 void *data
, size_t n
, off_t offset
)
258 return SMB_VFS_NEXT_PREAD(handle
, fsp
, data
, n
, offset
);
261 struct skel_pread_state
{
263 struct vfs_aio_state vfs_aio_state
;
266 static void skel_pread_done(struct tevent_req
*subreq
);
268 static struct tevent_req
*skel_pread_send(struct vfs_handle_struct
*handle
,
270 struct tevent_context
*ev
,
271 struct files_struct
*fsp
,
272 void *data
, size_t n
, off_t offset
)
274 struct tevent_req
*req
, *subreq
;
275 struct skel_pread_state
*state
;
277 req
= tevent_req_create(mem_ctx
, &state
, struct skel_pread_state
);
281 subreq
= SMB_VFS_NEXT_PREAD_SEND(state
, ev
, handle
, fsp
, data
,
283 if (tevent_req_nomem(subreq
, req
)) {
284 return tevent_req_post(req
, ev
);
286 tevent_req_set_callback(subreq
, skel_pread_done
, req
);
290 static void skel_pread_done(struct tevent_req
*subreq
)
292 struct tevent_req
*req
=
293 tevent_req_callback_data(subreq
, struct tevent_req
);
294 struct skel_pread_state
*state
=
295 tevent_req_data(req
, struct skel_pread_state
);
297 state
->ret
= SMB_VFS_PREAD_RECV(subreq
, &state
->vfs_aio_state
);
299 tevent_req_done(req
);
302 static ssize_t
skel_pread_recv(struct tevent_req
*req
,
303 struct vfs_aio_state
*vfs_aio_state
)
305 struct skel_pread_state
*state
=
306 tevent_req_data(req
, struct skel_pread_state
);
308 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
311 *vfs_aio_state
= state
->vfs_aio_state
;
315 static ssize_t
skel_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
,
316 const void *data
, size_t n
, off_t offset
)
318 return SMB_VFS_NEXT_PWRITE(handle
, fsp
, data
, n
, offset
);
321 struct skel_pwrite_state
{
323 struct vfs_aio_state vfs_aio_state
;
326 static void skel_pwrite_done(struct tevent_req
*subreq
);
328 static struct tevent_req
*skel_pwrite_send(struct vfs_handle_struct
*handle
,
330 struct tevent_context
*ev
,
331 struct files_struct
*fsp
,
333 size_t n
, off_t offset
)
335 struct tevent_req
*req
, *subreq
;
336 struct skel_pwrite_state
*state
;
338 req
= tevent_req_create(mem_ctx
, &state
, struct skel_pwrite_state
);
342 subreq
= SMB_VFS_NEXT_PWRITE_SEND(state
, ev
, handle
, fsp
, data
,
344 if (tevent_req_nomem(subreq
, req
)) {
345 return tevent_req_post(req
, ev
);
347 tevent_req_set_callback(subreq
, skel_pwrite_done
, req
);
351 static void skel_pwrite_done(struct tevent_req
*subreq
)
353 struct tevent_req
*req
=
354 tevent_req_callback_data(subreq
, struct tevent_req
);
355 struct skel_pwrite_state
*state
=
356 tevent_req_data(req
, struct skel_pwrite_state
);
358 state
->ret
= SMB_VFS_PWRITE_RECV(subreq
, &state
->vfs_aio_state
);
360 tevent_req_done(req
);
363 static ssize_t
skel_pwrite_recv(struct tevent_req
*req
,
364 struct vfs_aio_state
*vfs_aio_state
)
366 struct skel_pwrite_state
*state
=
367 tevent_req_data(req
, struct skel_pwrite_state
);
369 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
372 *vfs_aio_state
= state
->vfs_aio_state
;
376 static off_t
skel_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
,
377 off_t offset
, int whence
)
379 return SMB_VFS_NEXT_LSEEK(handle
, fsp
, offset
, whence
);
382 static ssize_t
skel_sendfile(vfs_handle_struct
*handle
, int tofd
,
383 files_struct
*fromfsp
, const DATA_BLOB
*hdr
,
384 off_t offset
, size_t n
)
386 return SMB_VFS_NEXT_SENDFILE(handle
, tofd
, fromfsp
, hdr
, offset
, n
);
389 static ssize_t
skel_recvfile(vfs_handle_struct
*handle
, int fromfd
,
390 files_struct
*tofsp
, off_t offset
, size_t n
)
392 return SMB_VFS_NEXT_RECVFILE(handle
, fromfd
, tofsp
, offset
, n
);
395 static int skel_renameat(vfs_handle_struct
*handle
,
396 files_struct
*srcfsp
,
397 const struct smb_filename
*smb_fname_src
,
398 files_struct
*dstfsp
,
399 const struct smb_filename
*smb_fname_dst
)
401 return SMB_VFS_NEXT_RENAMEAT(handle
,
408 struct skel_fsync_state
{
410 struct vfs_aio_state vfs_aio_state
;
413 static void skel_fsync_done(struct tevent_req
*subreq
);
415 static struct tevent_req
*skel_fsync_send(struct vfs_handle_struct
*handle
,
417 struct tevent_context
*ev
,
418 struct files_struct
*fsp
)
420 struct tevent_req
*req
, *subreq
;
421 struct skel_fsync_state
*state
;
423 req
= tevent_req_create(mem_ctx
, &state
, struct skel_fsync_state
);
427 subreq
= SMB_VFS_NEXT_FSYNC_SEND(state
, ev
, handle
, fsp
);
428 if (tevent_req_nomem(subreq
, req
)) {
429 return tevent_req_post(req
, ev
);
431 tevent_req_set_callback(subreq
, skel_fsync_done
, req
);
435 static void skel_fsync_done(struct tevent_req
*subreq
)
437 struct tevent_req
*req
=
438 tevent_req_callback_data(subreq
, struct tevent_req
);
439 struct skel_fsync_state
*state
=
440 tevent_req_data(req
, struct skel_fsync_state
);
442 state
->ret
= SMB_VFS_FSYNC_RECV(subreq
, &state
->vfs_aio_state
);
444 tevent_req_done(req
);
447 static int skel_fsync_recv(struct tevent_req
*req
,
448 struct vfs_aio_state
*vfs_aio_state
)
450 struct skel_fsync_state
*state
=
451 tevent_req_data(req
, struct skel_fsync_state
);
453 if (tevent_req_is_unix_error(req
, &vfs_aio_state
->error
)) {
456 *vfs_aio_state
= state
->vfs_aio_state
;
460 static int skel_stat(vfs_handle_struct
*handle
, struct smb_filename
*smb_fname
)
462 return SMB_VFS_NEXT_STAT(handle
, smb_fname
);
465 static int skel_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
,
466 SMB_STRUCT_STAT
*sbuf
)
468 return SMB_VFS_NEXT_FSTAT(handle
, fsp
, sbuf
);
471 static int skel_lstat(vfs_handle_struct
*handle
,
472 struct smb_filename
*smb_fname
)
474 return SMB_VFS_NEXT_LSTAT(handle
, smb_fname
);
477 static int skel_fstatat(
478 struct vfs_handle_struct
*handle
,
479 const struct files_struct
*dirfsp
,
480 const struct smb_filename
*smb_fname
,
481 SMB_STRUCT_STAT
*sbuf
,
484 return SMB_VFS_NEXT_FSTATAT(handle
, dirfsp
, smb_fname
, sbuf
, flags
);
487 static uint64_t skel_get_alloc_size(struct vfs_handle_struct
*handle
,
488 struct files_struct
*fsp
,
489 const SMB_STRUCT_STAT
*sbuf
)
491 return SMB_VFS_NEXT_GET_ALLOC_SIZE(handle
, fsp
, sbuf
);
494 static int skel_unlinkat(vfs_handle_struct
*handle
,
495 struct files_struct
*dirfsp
,
496 const struct smb_filename
*smb_fname
,
499 return SMB_VFS_NEXT_UNLINKAT(handle
,
505 static int skel_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
,
508 return SMB_VFS_NEXT_FCHMOD(handle
, fsp
, mode
);
511 static int skel_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
,
512 uid_t uid
, gid_t gid
)
514 return SMB_VFS_NEXT_FCHOWN(handle
, fsp
, uid
, gid
);
517 static int skel_lchown(vfs_handle_struct
*handle
,
518 const struct smb_filename
*smb_fname
,
522 return SMB_VFS_NEXT_LCHOWN(handle
, smb_fname
, uid
, gid
);
525 static int skel_chdir(vfs_handle_struct
*handle
,
526 const struct smb_filename
*smb_fname
)
528 return SMB_VFS_NEXT_CHDIR(handle
, smb_fname
);
531 static struct smb_filename
*skel_getwd(vfs_handle_struct
*handle
,
534 return SMB_VFS_NEXT_GETWD(handle
, ctx
);
537 static int skel_fntimes(vfs_handle_struct
*handle
,
539 struct smb_file_time
*ft
)
541 return SMB_VFS_NEXT_FNTIMES(handle
, fsp
, ft
);
544 static int skel_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
,
547 return SMB_VFS_NEXT_FTRUNCATE(handle
, fsp
, offset
);
550 static int skel_fallocate(vfs_handle_struct
*handle
, files_struct
*fsp
,
551 uint32_t mode
, off_t offset
, off_t len
)
553 return SMB_VFS_NEXT_FALLOCATE(handle
, fsp
, mode
, offset
, len
);
556 static bool skel_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int op
,
557 off_t offset
, off_t count
, int type
)
559 return SMB_VFS_NEXT_LOCK(handle
, fsp
, op
, offset
, count
, type
);
562 static int skel_filesystem_sharemode(struct vfs_handle_struct
*handle
,
563 struct files_struct
*fsp
,
565 uint32_t access_mask
)
567 return SMB_VFS_NEXT_FILESYSTEM_SHAREMODE(handle
,
573 static int skel_fcntl(struct vfs_handle_struct
*handle
,
574 struct files_struct
*fsp
, int cmd
, va_list cmd_arg
)
580 va_copy(dup_cmd_arg
, cmd_arg
);
581 arg
= va_arg(dup_cmd_arg
, void *);
582 result
= SMB_VFS_NEXT_FCNTL(handle
, fsp
, cmd
, arg
);
588 static int skel_linux_setlease(struct vfs_handle_struct
*handle
,
589 struct files_struct
*fsp
, int leasetype
)
591 return SMB_VFS_NEXT_LINUX_SETLEASE(handle
, fsp
, leasetype
);
594 static bool skel_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
,
595 off_t
*poffset
, off_t
*pcount
, int *ptype
,
598 return SMB_VFS_NEXT_GETLOCK(handle
, fsp
, poffset
, pcount
, ptype
, ppid
);
601 static int skel_symlinkat(vfs_handle_struct
*handle
,
602 const struct smb_filename
*link_contents
,
603 struct files_struct
*dirfsp
,
604 const struct smb_filename
*new_smb_fname
)
606 return SMB_VFS_NEXT_SYMLINKAT(handle
,
612 static int skel_vfs_readlinkat(vfs_handle_struct
*handle
,
613 const struct files_struct
*dirfsp
,
614 const struct smb_filename
*smb_fname
,
618 return SMB_VFS_NEXT_READLINKAT(handle
,
625 static int skel_linkat(vfs_handle_struct
*handle
,
626 files_struct
*srcfsp
,
627 const struct smb_filename
*old_smb_fname
,
628 files_struct
*dstfsp
,
629 const struct smb_filename
*new_smb_fname
,
632 return SMB_VFS_NEXT_LINKAT(handle
,
640 static int skel_mknodat(vfs_handle_struct
*handle
,
641 files_struct
*dirfsp
,
642 const struct smb_filename
*smb_fname
,
646 return SMB_VFS_NEXT_MKNODAT(handle
,
653 static struct smb_filename
*skel_realpath(vfs_handle_struct
*handle
,
655 const struct smb_filename
*smb_fname
)
657 return SMB_VFS_NEXT_REALPATH(handle
, ctx
, smb_fname
);
660 static int skel_fchflags(vfs_handle_struct
*handle
,
661 struct files_struct
*fsp
,
664 return SMB_VFS_NEXT_FCHFLAGS(handle
, fsp
, flags
);
667 static struct file_id
skel_file_id_create(vfs_handle_struct
*handle
,
668 const SMB_STRUCT_STAT
*sbuf
)
670 return SMB_VFS_NEXT_FILE_ID_CREATE(handle
, sbuf
);
673 static uint64_t skel_fs_file_id(vfs_handle_struct
*handle
,
674 const SMB_STRUCT_STAT
*sbuf
)
676 return SMB_VFS_NEXT_FS_FILE_ID(handle
, sbuf
);
679 struct skel_offload_read_state
{
680 struct vfs_handle_struct
*handle
;
686 static void skel_offload_read_done(struct tevent_req
*subreq
);
688 static struct tevent_req
*skel_offload_read_send(
690 struct tevent_context
*ev
,
691 struct vfs_handle_struct
*handle
,
692 struct files_struct
*fsp
,
698 struct tevent_req
*req
= NULL
;
699 struct skel_offload_read_state
*state
= NULL
;
700 struct tevent_req
*subreq
= NULL
;
702 req
= tevent_req_create(mem_ctx
, &state
, struct skel_offload_read_state
);
706 *state
= (struct skel_offload_read_state
) {
710 subreq
= SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx
, ev
, handle
, fsp
,
711 fsctl
, ttl
, offset
, to_copy
);
712 if (tevent_req_nomem(subreq
, req
)) {
713 return tevent_req_post(req
, ev
);
715 tevent_req_set_callback(subreq
, skel_offload_read_done
, req
);
719 static void skel_offload_read_done(struct tevent_req
*subreq
)
721 struct tevent_req
*req
= tevent_req_callback_data(
722 subreq
, struct tevent_req
);
723 struct skel_offload_read_state
*state
= tevent_req_data(
724 req
, struct skel_offload_read_state
);
727 status
= SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq
,
734 if (tevent_req_nterror(req
, status
)) {
738 tevent_req_done(req
);
742 static NTSTATUS
skel_offload_read_recv(struct tevent_req
*req
,
743 struct vfs_handle_struct
*handle
,
749 struct skel_offload_read_state
*state
= tevent_req_data(
750 req
, struct skel_offload_read_state
);
754 if (tevent_req_is_nterror(req
, &status
)) {
755 tevent_req_received(req
);
759 token
= data_blob_talloc(mem_ctx
,
761 state
->token
.length
);
763 tevent_req_received(req
);
765 if (token
.data
== NULL
) {
766 return NT_STATUS_NO_MEMORY
;
769 *flags
= state
->flags
;
770 *xferlen
= state
->xferlen
;
775 struct skel_offload_write_state
{
776 struct vfs_handle_struct
*handle
;
779 static void skel_offload_write_done(struct tevent_req
*subreq
);
781 static struct tevent_req
*skel_offload_write_send(struct vfs_handle_struct
*handle
,
783 struct tevent_context
*ev
,
786 off_t transfer_offset
,
787 struct files_struct
*dest_fsp
,
791 struct tevent_req
*req
;
792 struct tevent_req
*subreq
;
793 struct skel_offload_write_state
*state
;
795 req
= tevent_req_create(mem_ctx
, &state
, struct skel_offload_write_state
);
800 state
->handle
= handle
;
801 subreq
= SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle
, state
, ev
,
802 fsctl
, token
, transfer_offset
,
803 dest_fsp
, dest_off
, num
);
804 if (tevent_req_nomem(subreq
, req
)) {
805 return tevent_req_post(req
, ev
);
808 tevent_req_set_callback(subreq
, skel_offload_write_done
, req
);
812 static void skel_offload_write_done(struct tevent_req
*subreq
)
814 struct tevent_req
*req
= tevent_req_callback_data(
815 subreq
, struct tevent_req
);
816 struct skel_offload_write_state
*state
817 = tevent_req_data(req
, struct skel_offload_write_state
);
820 status
= SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state
->handle
,
824 if (tevent_req_nterror(req
, status
)) {
827 tevent_req_done(req
);
830 static NTSTATUS
skel_offload_write_recv(struct vfs_handle_struct
*handle
,
831 struct tevent_req
*req
,
834 struct skel_offload_write_state
*state
835 = tevent_req_data(req
, struct skel_offload_write_state
);
838 *copied
= state
->copied
;
839 if (tevent_req_is_nterror(req
, &status
)) {
840 tevent_req_received(req
);
844 tevent_req_received(req
);
848 static NTSTATUS
skel_fget_compression(struct vfs_handle_struct
*handle
,
850 struct files_struct
*fsp
,
851 uint16_t *_compression_fmt
)
853 return SMB_VFS_NEXT_FGET_COMPRESSION(handle
, mem_ctx
, fsp
,
857 static NTSTATUS
skel_set_compression(struct vfs_handle_struct
*handle
,
859 struct files_struct
*fsp
,
860 uint16_t compression_fmt
)
862 return SMB_VFS_NEXT_SET_COMPRESSION(handle
, mem_ctx
, fsp
,
866 static NTSTATUS
skel_fstreaminfo(struct vfs_handle_struct
*handle
,
867 struct files_struct
*fsp
,
869 unsigned int *num_streams
,
870 struct stream_struct
**streams
)
872 return SMB_VFS_NEXT_FSTREAMINFO(handle
,
879 static NTSTATUS
skel_get_real_filename_at(struct vfs_handle_struct
*handle
,
880 struct files_struct
*dirfsp
,
885 return SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
886 handle
, dirfsp
, name
, mem_ctx
, found_name
);
889 static const char *skel_connectpath(
890 struct vfs_handle_struct
*handle
,
891 const struct files_struct
*dirfsp
,
892 const struct smb_filename
*smb_fname
)
894 return SMB_VFS_NEXT_CONNECTPATH(handle
, dirfsp
, smb_fname
);
897 static NTSTATUS
skel_brl_lock_windows(struct vfs_handle_struct
*handle
,
898 struct byte_range_lock
*br_lck
,
899 struct lock_struct
*plock
)
901 return SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle
, br_lck
, plock
);
904 static bool skel_brl_unlock_windows(struct vfs_handle_struct
*handle
,
905 struct byte_range_lock
*br_lck
,
906 const struct lock_struct
*plock
)
908 return SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle
, br_lck
, plock
);
911 static bool skel_strict_lock_check(struct vfs_handle_struct
*handle
,
912 struct files_struct
*fsp
,
913 struct lock_struct
*plock
)
915 return SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle
, fsp
, plock
);
918 static NTSTATUS
skel_translate_name(struct vfs_handle_struct
*handle
,
919 const char *mapped_name
,
920 enum vfs_translate_direction direction
,
921 TALLOC_CTX
*mem_ctx
, char **pmapped_name
)
923 return SMB_VFS_NEXT_TRANSLATE_NAME(handle
, mapped_name
, direction
,
924 mem_ctx
, pmapped_name
);
927 static NTSTATUS
skel_parent_pathname(struct vfs_handle_struct
*handle
,
929 const struct smb_filename
*smb_fname_in
,
930 struct smb_filename
**parent_dir_out
,
931 struct smb_filename
**atname_out
)
933 return SMB_VFS_NEXT_PARENT_PATHNAME(handle
,
940 static NTSTATUS
skel_fsctl(struct vfs_handle_struct
*handle
,
941 struct files_struct
*fsp
,
944 uint16_t req_flags
, /* Needed for UNICODE ... */
945 const uint8_t *_in_data
,
947 uint8_t ** _out_data
,
948 uint32_t max_out_len
, uint32_t *out_len
)
950 return SMB_VFS_NEXT_FSCTL(handle
,
956 in_len
, _out_data
, max_out_len
, out_len
);
959 static NTSTATUS
skel_freaddir_attr(struct vfs_handle_struct
*handle
,
960 struct files_struct
*fsp
,
962 struct readdir_attr_data
**pattr_data
)
964 return SMB_VFS_NEXT_FREADDIR_ATTR(handle
, fsp
, mem_ctx
, pattr_data
);
967 struct skel_get_dos_attributes_state
{
968 struct vfs_aio_state aio_state
;
972 static void skel_get_dos_attributes_done(struct tevent_req
*subreq
);
974 static struct tevent_req
*skel_get_dos_attributes_send(
976 struct tevent_context
*ev
,
977 struct vfs_handle_struct
*handle
,
978 files_struct
*dir_fsp
,
979 struct smb_filename
*smb_fname
)
981 struct tevent_req
*req
= NULL
;
982 struct skel_get_dos_attributes_state
*state
= NULL
;
983 struct tevent_req
*subreq
= NULL
;
985 req
= tevent_req_create(mem_ctx
, &state
,
986 struct skel_get_dos_attributes_state
);
991 subreq
= SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_SEND(mem_ctx
,
996 if (tevent_req_nomem(subreq
, req
)) {
997 return tevent_req_post(req
, ev
);
999 tevent_req_set_callback(subreq
, skel_get_dos_attributes_done
, req
);
1004 static void skel_get_dos_attributes_done(struct tevent_req
*subreq
)
1006 struct tevent_req
*req
=
1007 tevent_req_callback_data(subreq
,
1009 struct skel_get_dos_attributes_state
*state
=
1010 tevent_req_data(req
,
1011 struct skel_get_dos_attributes_state
);
1014 status
= SMB_VFS_NEXT_GET_DOS_ATTRIBUTES_RECV(subreq
,
1017 TALLOC_FREE(subreq
);
1018 if (tevent_req_nterror(req
, status
)) {
1022 tevent_req_done(req
);
1026 static NTSTATUS
skel_get_dos_attributes_recv(struct tevent_req
*req
,
1027 struct vfs_aio_state
*aio_state
,
1030 struct skel_get_dos_attributes_state
*state
=
1031 tevent_req_data(req
,
1032 struct skel_get_dos_attributes_state
);
1035 if (tevent_req_is_nterror(req
, &status
)) {
1036 tevent_req_received(req
);
1040 *aio_state
= state
->aio_state
;
1041 *dosmode
= state
->dosmode
;
1042 tevent_req_received(req
);
1043 return NT_STATUS_OK
;
1046 static NTSTATUS
skel_fget_dos_attributes(struct vfs_handle_struct
*handle
,
1047 struct files_struct
*fsp
,
1050 return SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle
,
1055 static NTSTATUS
skel_fset_dos_attributes(struct vfs_handle_struct
*handle
,
1056 struct files_struct
*fsp
,
1059 return SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle
,
1064 static NTSTATUS
skel_fget_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
,
1065 uint32_t security_info
,
1066 TALLOC_CTX
*mem_ctx
,
1067 struct security_descriptor
**ppdesc
)
1069 return SMB_VFS_NEXT_FGET_NT_ACL(handle
, fsp
, security_info
, mem_ctx
,
1073 static NTSTATUS
skel_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
,
1074 uint32_t security_info_sent
,
1075 const struct security_descriptor
*psd
)
1077 return SMB_VFS_NEXT_FSET_NT_ACL(handle
, fsp
, security_info_sent
, psd
);
1080 static SMB_ACL_T
skel_sys_acl_get_fd(vfs_handle_struct
*handle
,
1082 SMB_ACL_TYPE_T type
,
1083 TALLOC_CTX
*mem_ctx
)
1085 return SMB_VFS_NEXT_SYS_ACL_GET_FD(handle
, fsp
, type
, mem_ctx
);
1088 static int skel_sys_acl_blob_get_fd(vfs_handle_struct
*handle
,
1089 files_struct
*fsp
, TALLOC_CTX
*mem_ctx
,
1090 char **blob_description
, DATA_BLOB
*blob
)
1092 return SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle
, fsp
, mem_ctx
,
1093 blob_description
, blob
);
1096 static int skel_sys_acl_set_fd(vfs_handle_struct
*handle
,
1097 struct files_struct
*fsp
,
1098 SMB_ACL_TYPE_T type
,
1101 return SMB_VFS_NEXT_SYS_ACL_SET_FD(handle
, fsp
, type
, theacl
);
1104 static int skel_sys_acl_delete_def_fd(vfs_handle_struct
*handle
,
1105 struct files_struct
*fsp
)
1107 return SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FD(handle
, fsp
);
1110 struct skel_getxattrat_state
{
1111 struct vfs_aio_state aio_state
;
1113 uint8_t *xattr_value
;
1116 static void skel_getxattrat_done(struct tevent_req
*subreq
);
1118 static struct tevent_req
*skel_getxattrat_send(
1119 TALLOC_CTX
*mem_ctx
,
1120 struct tevent_context
*ev
,
1121 struct vfs_handle_struct
*handle
,
1122 files_struct
*dir_fsp
,
1123 const struct smb_filename
*smb_fname
,
1124 const char *xattr_name
,
1127 struct tevent_req
*req
= NULL
;
1128 struct skel_getxattrat_state
*state
= NULL
;
1129 struct tevent_req
*subreq
= NULL
;
1131 req
= tevent_req_create(mem_ctx
, &state
,
1132 struct skel_getxattrat_state
);
1137 subreq
= SMB_VFS_NEXT_GETXATTRAT_SEND(state
,
1144 if (tevent_req_nomem(subreq
, req
)) {
1145 return tevent_req_post(req
, ev
);
1147 tevent_req_set_callback(subreq
, skel_getxattrat_done
, req
);
1152 static void skel_getxattrat_done(struct tevent_req
*subreq
)
1154 struct tevent_req
*req
= tevent_req_callback_data(
1155 subreq
, struct tevent_req
);
1156 struct skel_getxattrat_state
*state
= tevent_req_data(
1157 req
, struct skel_getxattrat_state
);
1159 state
->xattr_size
= SMB_VFS_NEXT_GETXATTRAT_RECV(subreq
,
1162 &state
->xattr_value
);
1163 TALLOC_FREE(subreq
);
1164 if (state
->xattr_size
== -1) {
1165 tevent_req_error(req
, state
->aio_state
.error
);
1169 tevent_req_done(req
);
1172 static ssize_t
skel_getxattrat_recv(struct tevent_req
*req
,
1173 struct vfs_aio_state
*aio_state
,
1174 TALLOC_CTX
*mem_ctx
,
1175 uint8_t **xattr_value
)
1177 struct skel_getxattrat_state
*state
= tevent_req_data(
1178 req
, struct skel_getxattrat_state
);
1181 if (tevent_req_is_unix_error(req
, &aio_state
->error
)) {
1182 tevent_req_received(req
);
1186 *aio_state
= state
->aio_state
;
1187 xattr_size
= state
->xattr_size
;
1188 if (xattr_value
!= NULL
) {
1189 *xattr_value
= talloc_move(mem_ctx
, &state
->xattr_value
);
1192 tevent_req_received(req
);
1196 static ssize_t
skel_fgetxattr(vfs_handle_struct
*handle
,
1197 struct files_struct
*fsp
, const char *name
,
1198 void *value
, size_t size
)
1200 return SMB_VFS_NEXT_FGETXATTR(handle
, fsp
, name
, value
, size
);
1203 static ssize_t
skel_flistxattr(vfs_handle_struct
*handle
,
1204 struct files_struct
*fsp
, char *list
,
1207 return SMB_VFS_NEXT_FLISTXATTR(handle
, fsp
, list
, size
);
1210 static int skel_fremovexattr(vfs_handle_struct
*handle
,
1211 struct files_struct
*fsp
, const char *name
)
1213 return SMB_VFS_NEXT_FREMOVEXATTR(handle
, fsp
, name
);
1216 static int skel_fsetxattr(vfs_handle_struct
*handle
, struct files_struct
*fsp
,
1217 const char *name
, const void *value
, size_t size
,
1220 return SMB_VFS_NEXT_FSETXATTR(handle
, fsp
, name
, value
, size
, flags
);
1223 static bool skel_aio_force(struct vfs_handle_struct
*handle
,
1224 struct files_struct
*fsp
)
1226 return SMB_VFS_NEXT_AIO_FORCE(handle
, fsp
);
1229 static NTSTATUS
skel_audit_file(struct vfs_handle_struct
*handle
,
1230 struct smb_filename
*file
,
1231 struct security_acl
*sacl
,
1232 uint32_t access_requested
,
1233 uint32_t access_denied
)
1235 return SMB_VFS_NEXT_AUDIT_FILE(handle
,
1242 static NTSTATUS
skel_durable_cookie(struct vfs_handle_struct
*handle
,
1243 struct files_struct
*fsp
,
1244 TALLOC_CTX
*mem_ctx
,
1247 return SMB_VFS_NEXT_DURABLE_COOKIE(handle
,
1253 static NTSTATUS
skel_durable_disconnect(struct vfs_handle_struct
*handle
,
1254 struct files_struct
*fsp
,
1255 const DATA_BLOB old_cookie
,
1256 TALLOC_CTX
*mem_ctx
,
1257 DATA_BLOB
*new_cookie
)
1259 return SMB_VFS_NEXT_DURABLE_DISCONNECT(handle
,
1266 static NTSTATUS
skel_durable_reconnect(struct vfs_handle_struct
*handle
,
1267 struct smb_request
*smb1req
,
1268 struct smbXsrv_open
*op
,
1269 const DATA_BLOB old_cookie
,
1270 TALLOC_CTX
*mem_ctx
,
1271 struct files_struct
**fsp
,
1272 DATA_BLOB
*new_cookie
)
1274 return SMB_VFS_NEXT_DURABLE_RECONNECT(handle
,
1283 /* VFS operations structure */
1285 static struct vfs_fn_pointers skel_transparent_fns
= {
1286 /* Disk operations */
1288 .connect_fn
= skel_connect
,
1289 .disconnect_fn
= skel_disconnect
,
1290 .disk_free_fn
= skel_disk_free
,
1291 .get_quota_fn
= skel_get_quota
,
1292 .set_quota_fn
= skel_set_quota
,
1293 .get_shadow_copy_data_fn
= skel_get_shadow_copy_data
,
1294 .statvfs_fn
= skel_statvfs
,
1295 .fs_capabilities_fn
= skel_fs_capabilities
,
1296 .get_dfs_referrals_fn
= skel_get_dfs_referrals
,
1297 .create_dfs_pathat_fn
= skel_create_dfs_pathat
,
1298 .read_dfs_pathat_fn
= skel_read_dfs_pathat
,
1299 .snap_check_path_fn
= skel_snap_check_path
,
1300 .snap_create_fn
= skel_snap_create
,
1301 .snap_delete_fn
= skel_snap_delete
,
1303 /* Directory operations */
1305 .fdopendir_fn
= skel_fdopendir
,
1306 .readdir_fn
= skel_readdir
,
1307 .seekdir_fn
= skel_seekdir
,
1308 .telldir_fn
= skel_telldir
,
1309 .rewind_dir_fn
= skel_rewind_dir
,
1310 .mkdirat_fn
= skel_mkdirat
,
1311 .closedir_fn
= skel_closedir
,
1313 /* File operations */
1315 .openat_fn
= skel_openat
,
1316 .create_file_fn
= skel_create_file
,
1317 .close_fn
= skel_close_fn
,
1318 .pread_fn
= skel_pread
,
1319 .pread_send_fn
= skel_pread_send
,
1320 .pread_recv_fn
= skel_pread_recv
,
1321 .pwrite_fn
= skel_pwrite
,
1322 .pwrite_send_fn
= skel_pwrite_send
,
1323 .pwrite_recv_fn
= skel_pwrite_recv
,
1324 .lseek_fn
= skel_lseek
,
1325 .sendfile_fn
= skel_sendfile
,
1326 .recvfile_fn
= skel_recvfile
,
1327 .renameat_fn
= skel_renameat
,
1328 .fsync_send_fn
= skel_fsync_send
,
1329 .fsync_recv_fn
= skel_fsync_recv
,
1330 .stat_fn
= skel_stat
,
1331 .fstat_fn
= skel_fstat
,
1332 .lstat_fn
= skel_lstat
,
1333 .fstatat_fn
= skel_fstatat
,
1334 .get_alloc_size_fn
= skel_get_alloc_size
,
1335 .unlinkat_fn
= skel_unlinkat
,
1336 .fchmod_fn
= skel_fchmod
,
1337 .fchown_fn
= skel_fchown
,
1338 .lchown_fn
= skel_lchown
,
1339 .chdir_fn
= skel_chdir
,
1340 .getwd_fn
= skel_getwd
,
1341 .fntimes_fn
= skel_fntimes
,
1342 .ftruncate_fn
= skel_ftruncate
,
1343 .fallocate_fn
= skel_fallocate
,
1344 .lock_fn
= skel_lock
,
1345 .filesystem_sharemode_fn
= skel_filesystem_sharemode
,
1346 .fcntl_fn
= skel_fcntl
,
1347 .linux_setlease_fn
= skel_linux_setlease
,
1348 .getlock_fn
= skel_getlock
,
1349 .symlinkat_fn
= skel_symlinkat
,
1350 .readlinkat_fn
= skel_vfs_readlinkat
,
1351 .linkat_fn
= skel_linkat
,
1352 .mknodat_fn
= skel_mknodat
,
1353 .realpath_fn
= skel_realpath
,
1354 .fchflags_fn
= skel_fchflags
,
1355 .file_id_create_fn
= skel_file_id_create
,
1356 .fs_file_id_fn
= skel_fs_file_id
,
1357 .offload_read_send_fn
= skel_offload_read_send
,
1358 .offload_read_recv_fn
= skel_offload_read_recv
,
1359 .offload_write_send_fn
= skel_offload_write_send
,
1360 .offload_write_recv_fn
= skel_offload_write_recv
,
1361 .fget_compression_fn
= skel_fget_compression
,
1362 .set_compression_fn
= skel_set_compression
,
1364 .fstreaminfo_fn
= skel_fstreaminfo
,
1365 .get_real_filename_at_fn
= skel_get_real_filename_at
,
1366 .connectpath_fn
= skel_connectpath
,
1367 .brl_lock_windows_fn
= skel_brl_lock_windows
,
1368 .brl_unlock_windows_fn
= skel_brl_unlock_windows
,
1369 .strict_lock_check_fn
= skel_strict_lock_check
,
1370 .translate_name_fn
= skel_translate_name
,
1371 .parent_pathname_fn
= skel_parent_pathname
,
1372 .fsctl_fn
= skel_fsctl
,
1373 .freaddir_attr_fn
= skel_freaddir_attr
,
1374 .audit_file_fn
= skel_audit_file
,
1376 /* DOS attributes. */
1377 .get_dos_attributes_send_fn
= skel_get_dos_attributes_send
,
1378 .get_dos_attributes_recv_fn
= skel_get_dos_attributes_recv
,
1379 .fget_dos_attributes_fn
= skel_fget_dos_attributes
,
1380 .fset_dos_attributes_fn
= skel_fset_dos_attributes
,
1382 /* NT ACL operations. */
1384 .fget_nt_acl_fn
= skel_fget_nt_acl
,
1385 .fset_nt_acl_fn
= skel_fset_nt_acl
,
1387 /* POSIX ACL operations. */
1389 .sys_acl_get_fd_fn
= skel_sys_acl_get_fd
,
1390 .sys_acl_blob_get_fd_fn
= skel_sys_acl_blob_get_fd
,
1391 .sys_acl_set_fd_fn
= skel_sys_acl_set_fd
,
1392 .sys_acl_delete_def_fd_fn
= skel_sys_acl_delete_def_fd
,
1394 /* EA operations. */
1395 .getxattrat_send_fn
= skel_getxattrat_send
,
1396 .getxattrat_recv_fn
= skel_getxattrat_recv
,
1397 .fgetxattr_fn
= skel_fgetxattr
,
1398 .flistxattr_fn
= skel_flistxattr
,
1399 .fremovexattr_fn
= skel_fremovexattr
,
1400 .fsetxattr_fn
= skel_fsetxattr
,
1402 /* aio operations */
1403 .aio_force_fn
= skel_aio_force
,
1405 /* durable handle operations */
1406 .durable_cookie_fn
= skel_durable_cookie
,
1407 .durable_disconnect_fn
= skel_durable_disconnect
,
1408 .durable_reconnect_fn
= skel_durable_reconnect
,
1412 NTSTATUS
vfs_skel_transparent_init(TALLOC_CTX
*ctx
)
1415 * smb_vfs_assert_all_fns() is only needed in
1416 * order to have a complete example.
1418 * A transparent vfs module typically don't
1419 * need to implement every calls.
1421 smb_vfs_assert_all_fns(&skel_transparent_fns
, "skel_transparent");
1422 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "skel_transparent",
1423 &skel_transparent_fns
);