s3: VFS: Change SMB_VFS_STATVFS to use const struct smb_filename * instead of const...
[bbaumbach/samba-autobuild/.git] / examples / VFS / skel_opaque.c
1 /* 
2  * Skeleton VFS module.  Implements dummy versions of all VFS
3  * functions.
4  *
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
9  *
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.
14  *  
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.
19  *  
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/>.
22  */
23
24 #include "../source3/include/includes.h"
25 #include "lib/util/tevent_ntstatus.h"
26
27 /* PLEASE,PLEASE READ THE VFS MODULES CHAPTER OF THE 
28    SAMBA DEVELOPERS GUIDE!!!!!!
29  */
30
31 /* If you take this file as template for your module
32  * you must re-implement every function.
33  */
34
35 static int skel_connect(vfs_handle_struct *handle, const char *service,
36                         const char *user)
37 {
38         errno = ENOSYS;
39         return -1;
40 }
41
42 static void skel_disconnect(vfs_handle_struct *handle)
43 {
44         ;
45 }
46
47 static uint64_t skel_disk_free(vfs_handle_struct *handle,
48                                 const struct smb_filename *smb_fname,
49                                 uint64_t *bsize,
50                                 uint64_t *dfree,
51                                 uint64_t *dsize)
52 {
53         *bsize = 0;
54         *dfree = 0;
55         *dsize = 0;
56         return 0;
57 }
58
59 static int skel_get_quota(vfs_handle_struct *handle,
60                                 const struct smb_filename *smb_fname,
61                                 enum SMB_QUOTA_TYPE qtype,
62                                 unid_t id,
63                                 SMB_DISK_QUOTA *dq)
64 {
65         errno = ENOSYS;
66         return -1;
67 }
68
69 static int skel_set_quota(vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype,
70                           unid_t id, SMB_DISK_QUOTA *dq)
71 {
72         errno = ENOSYS;
73         return -1;
74 }
75
76 static int skel_get_shadow_copy_data(vfs_handle_struct *handle,
77                                      files_struct *fsp,
78                                      struct shadow_copy_data *shadow_copy_data,
79                                      bool labels)
80 {
81         errno = ENOSYS;
82         return -1;
83 }
84
85 static int skel_statvfs(struct vfs_handle_struct *handle,
86                                 const struct smb_filename *smb_fname,
87                                 struct vfs_statvfs_struct *statbuf)
88 {
89         errno = ENOSYS;
90         return -1;
91 }
92
93 static uint32_t skel_fs_capabilities(struct vfs_handle_struct *handle,
94                                      enum timestamp_set_resolution *p_ts_res)
95 {
96         return 0;
97 }
98
99 static NTSTATUS skel_get_dfs_referrals(struct vfs_handle_struct *handle,
100                                        struct dfs_GetDFSReferral *r)
101 {
102         return NT_STATUS_NOT_IMPLEMENTED;
103 }
104
105 static DIR *skel_opendir(vfs_handle_struct *handle,
106                         const struct smb_filename *smb_fname,
107                         const char *mask,
108                         uint32_t attr)
109 {
110         return NULL;
111 }
112
113 static NTSTATUS skel_snap_check_path(struct vfs_handle_struct *handle,
114                                      TALLOC_CTX *mem_ctx,
115                                      const char *service_path,
116                                      char **base_volume)
117 {
118         return NT_STATUS_NOT_SUPPORTED;
119 }
120
121 static NTSTATUS skel_snap_create(struct vfs_handle_struct *handle,
122                                  TALLOC_CTX *mem_ctx,
123                                  const char *base_volume,
124                                  time_t *tstamp,
125                                  bool rw,
126                                  char **base_path,
127                                  char **snap_path)
128 {
129         return NT_STATUS_NOT_SUPPORTED;
130 }
131
132 static NTSTATUS skel_snap_delete(struct vfs_handle_struct *handle,
133                                  TALLOC_CTX *mem_ctx,
134                                  char *base_path,
135                                  char *snap_path)
136 {
137         return NT_STATUS_NOT_SUPPORTED;
138 }
139
140 static DIR *skel_fdopendir(vfs_handle_struct *handle, files_struct *fsp,
141                            const char *mask, uint32_t attr)
142 {
143         return NULL;
144 }
145
146 static struct dirent *skel_readdir(vfs_handle_struct *handle,
147                                    DIR *dirp, SMB_STRUCT_STAT *sbuf)
148 {
149         return NULL;
150 }
151
152 static void skel_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
153 {
154         ;
155 }
156
157 static long skel_telldir(vfs_handle_struct *handle, DIR *dirp)
158 {
159         return (long)-1;
160 }
161
162 static void skel_rewind_dir(vfs_handle_struct *handle, DIR *dirp)
163 {
164         ;
165 }
166
167 static int skel_mkdir(vfs_handle_struct *handle,
168                 const struct smb_filename *smb_fname,
169                 mode_t mode)
170 {
171         errno = ENOSYS;
172         return -1;
173 }
174
175 static int skel_rmdir(vfs_handle_struct *handle,
176                 const struct smb_filename *smb_fname)
177 {
178         errno = ENOSYS;
179         return -1;
180 }
181
182 static int skel_closedir(vfs_handle_struct *handle, DIR *dir)
183 {
184         errno = ENOSYS;
185         return -1;
186 }
187
188 static void skel_init_search_op(struct vfs_handle_struct *handle, DIR *dirp)
189 {
190         ;
191 }
192
193 static int skel_open(vfs_handle_struct *handle, struct smb_filename *smb_fname,
194                      files_struct *fsp, int flags, mode_t mode)
195 {
196         errno = ENOSYS;
197         return -1;
198 }
199
200 static NTSTATUS skel_create_file(struct vfs_handle_struct *handle,
201                                  struct smb_request *req,
202                                  uint16_t root_dir_fid,
203                                  struct smb_filename *smb_fname,
204                                  uint32_t access_mask,
205                                  uint32_t share_access,
206                                  uint32_t create_disposition,
207                                  uint32_t create_options,
208                                  uint32_t file_attributes,
209                                  uint32_t oplock_request,
210                                  struct smb2_lease *lease,
211                                  uint64_t allocation_size,
212                                  uint32_t private_flags,
213                                  struct security_descriptor *sd,
214                                  struct ea_list *ea_list,
215                                  files_struct **result, int *pinfo,
216                                  const struct smb2_create_blobs *in_context_blobs,
217                                  struct smb2_create_blobs *out_context_blobs)
218 {
219         return NT_STATUS_NOT_IMPLEMENTED;
220 }
221
222 static int skel_close_fn(vfs_handle_struct *handle, files_struct *fsp)
223 {
224         errno = ENOSYS;
225         return -1;
226 }
227
228 static ssize_t skel_vfs_read(vfs_handle_struct *handle, files_struct *fsp,
229                              void *data, size_t n)
230 {
231         errno = ENOSYS;
232         return -1;
233 }
234
235 static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp,
236                           void *data, size_t n, off_t offset)
237 {
238         errno = ENOSYS;
239         return -1;
240 }
241
242 static struct tevent_req *skel_pread_send(struct vfs_handle_struct *handle,
243                                           TALLOC_CTX *mem_ctx,
244                                           struct tevent_context *ev,
245                                           struct files_struct *fsp,
246                                           void *data, size_t n, off_t offset)
247 {
248         return NULL;
249 }
250
251 static ssize_t skel_pread_recv(struct tevent_req *req,
252                                struct vfs_aio_state *vfs_aio_state)
253 {
254         vfs_aio_state->error = ENOSYS;
255         return -1;
256 }
257
258 static ssize_t skel_write(vfs_handle_struct *handle, files_struct *fsp,
259                           const void *data, size_t n)
260 {
261         errno = ENOSYS;
262         return -1;
263 }
264
265 static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp,
266                            const void *data, size_t n, off_t offset)
267 {
268         errno = ENOSYS;
269         return -1;
270 }
271
272 static struct tevent_req *skel_pwrite_send(struct vfs_handle_struct *handle,
273                                            TALLOC_CTX *mem_ctx,
274                                            struct tevent_context *ev,
275                                            struct files_struct *fsp,
276                                            const void *data,
277                                            size_t n, off_t offset)
278 {
279         return NULL;
280 }
281
282 static ssize_t skel_pwrite_recv(struct tevent_req *req,
283                                 struct vfs_aio_state *vfs_aio_state)
284 {
285         vfs_aio_state->error = ENOSYS;
286         return -1;
287 }
288
289 static off_t skel_lseek(vfs_handle_struct *handle, files_struct *fsp,
290                         off_t offset, int whence)
291 {
292         errno = ENOSYS;
293         return (off_t) - 1;
294 }
295
296 static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd,
297                              files_struct *fromfsp, const DATA_BLOB *hdr,
298                              off_t offset, size_t n)
299 {
300         errno = ENOSYS;
301         return -1;
302 }
303
304 static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd,
305                              files_struct *tofsp, off_t offset, size_t n)
306 {
307         errno = ENOSYS;
308         return -1;
309 }
310
311 static int skel_rename(vfs_handle_struct *handle,
312                        const struct smb_filename *smb_fname_src,
313                        const struct smb_filename *smb_fname_dst)
314 {
315         errno = ENOSYS;
316         return -1;
317 }
318
319 static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp)
320 {
321         errno = ENOSYS;
322         return -1;
323 }
324
325 static struct tevent_req *skel_fsync_send(struct vfs_handle_struct *handle,
326                                           TALLOC_CTX *mem_ctx,
327                                           struct tevent_context *ev,
328                                           struct files_struct *fsp)
329 {
330         return NULL;
331 }
332
333 static int skel_fsync_recv(struct tevent_req *req,
334                            struct vfs_aio_state *vfs_aio_state)
335 {
336         vfs_aio_state->error = ENOSYS;
337         return -1;
338 }
339
340 static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
341 {
342         errno = ENOSYS;
343         return -1;
344 }
345
346 static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp,
347                       SMB_STRUCT_STAT *sbuf)
348 {
349         errno = ENOSYS;
350         return -1;
351 }
352
353 static int skel_lstat(vfs_handle_struct *handle,
354                       struct smb_filename *smb_fname)
355 {
356         errno = ENOSYS;
357         return -1;
358 }
359
360 static uint64_t skel_get_alloc_size(struct vfs_handle_struct *handle,
361                                     struct files_struct *fsp,
362                                     const SMB_STRUCT_STAT *sbuf)
363 {
364         errno = ENOSYS;
365         return -1;
366 }
367
368 static int skel_unlink(vfs_handle_struct *handle,
369                        const struct smb_filename *smb_fname)
370 {
371         errno = ENOSYS;
372         return -1;
373 }
374
375 static int skel_chmod(vfs_handle_struct *handle,
376                         const struct smb_filename *smb_fname,
377                         mode_t mode)
378 {
379         errno = ENOSYS;
380         return -1;
381 }
382
383 static int skel_fchmod(vfs_handle_struct *handle, files_struct *fsp,
384                        mode_t mode)
385 {
386         errno = ENOSYS;
387         return -1;
388 }
389
390 static int skel_chown(vfs_handle_struct *handle,
391                         const struct smb_filename *smb_fname,
392                         uid_t uid,
393                         gid_t gid)
394 {
395         errno = ENOSYS;
396         return -1;
397 }
398
399 static int skel_fchown(vfs_handle_struct *handle, files_struct *fsp,
400                        uid_t uid, gid_t gid)
401 {
402         errno = ENOSYS;
403         return -1;
404 }
405
406 static int skel_lchown(vfs_handle_struct *handle,
407                         const struct smb_filename *smb_fname,
408                         uid_t uid,
409                         gid_t gid)
410 {
411         errno = ENOSYS;
412         return -1;
413 }
414
415 static int skel_chdir(vfs_handle_struct *handle, const char *path)
416 {
417         errno = ENOSYS;
418         return -1;
419 }
420
421 static char *skel_getwd(vfs_handle_struct *handle)
422 {
423         errno = ENOSYS;
424         return NULL;
425 }
426
427 static int skel_ntimes(vfs_handle_struct *handle,
428                        const struct smb_filename *smb_fname,
429                        struct smb_file_time *ft)
430 {
431         errno = ENOSYS;
432         return -1;
433 }
434
435 static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
436                           off_t offset)
437 {
438         errno = ENOSYS;
439         return -1;
440 }
441
442 static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
443                           uint32_t mode, off_t offset, off_t len)
444 {
445         errno = ENOSYS;
446         return -1;
447 }
448
449 static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op,
450                       off_t offset, off_t count, int type)
451 {
452         errno = ENOSYS;
453         return false;
454 }
455
456 static int skel_kernel_flock(struct vfs_handle_struct *handle,
457                              struct files_struct *fsp,
458                              uint32_t share_mode, uint32_t access_mask)
459 {
460         errno = ENOSYS;
461         return -1;
462 }
463
464 static int skel_linux_setlease(struct vfs_handle_struct *handle,
465                                struct files_struct *fsp, int leasetype)
466 {
467         errno = ENOSYS;
468         return -1;
469 }
470
471 static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp,
472                          off_t *poffset, off_t *pcount, int *ptype,
473                          pid_t *ppid)
474 {
475         errno = ENOSYS;
476         return false;
477 }
478
479 static int skel_symlink(vfs_handle_struct *handle, const char *oldpath,
480                         const char *newpath)
481 {
482         errno = ENOSYS;
483         return -1;
484 }
485
486 static int skel_vfs_readlink(vfs_handle_struct *handle, const char *path,
487                              char *buf, size_t bufsiz)
488 {
489         errno = ENOSYS;
490         return -1;
491 }
492
493 static int skel_link(vfs_handle_struct *handle,
494                         const struct smb_filename *old_smb_fname,
495                         const struct smb_filename *new_smb_fname)
496 {
497         errno = ENOSYS;
498         return -1;
499 }
500
501 static int skel_mknod(vfs_handle_struct *handle,
502                         const struct smb_filename *smb_fname,
503                         mode_t mode,
504                         SMB_DEV_T dev)
505 {
506         errno = ENOSYS;
507         return -1;
508 }
509
510 static char *skel_realpath(vfs_handle_struct *handle, const char *path)
511 {
512         errno = ENOSYS;
513         return NULL;
514 }
515
516 static int skel_chflags(vfs_handle_struct *handle,
517                         const struct smb_filename *smb_fname,
518                         uint flags)
519 {
520         errno = ENOSYS;
521         return -1;
522 }
523
524 static struct file_id skel_file_id_create(vfs_handle_struct *handle,
525                                           const SMB_STRUCT_STAT *sbuf)
526 {
527         struct file_id id;
528         ZERO_STRUCT(id);
529         errno = ENOSYS;
530         return id;
531 }
532
533 struct skel_cc_state {
534         uint64_t unused;
535 };
536 static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
537                                                TALLOC_CTX *mem_ctx,
538                                                struct tevent_context *ev,
539                                                struct files_struct *src_fsp,
540                                                off_t src_off,
541                                                struct files_struct *dest_fsp,
542                                                off_t dest_off,
543                                                off_t num,
544                                                uint32_t flags)
545 {
546         struct tevent_req *req;
547         struct skel_cc_state *cc_state;
548
549         req = tevent_req_create(mem_ctx, &cc_state, struct skel_cc_state);
550         if (req == NULL) {
551                 return NULL;
552         }
553
554         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
555         return tevent_req_post(req, ev);
556 }
557
558 static NTSTATUS skel_copy_chunk_recv(struct vfs_handle_struct *handle,
559                                      struct tevent_req *req,
560                                      off_t *copied)
561 {
562         NTSTATUS status;
563
564         if (tevent_req_is_nterror(req, &status)) {
565                 tevent_req_received(req);
566                 return status;
567         }
568         tevent_req_received(req);
569
570         return NT_STATUS_OK;
571 }
572
573 static NTSTATUS skel_get_compression(struct vfs_handle_struct *handle,
574                                      TALLOC_CTX *mem_ctx,
575                                      struct files_struct *fsp,
576                                      struct smb_filename *smb_fname,
577                                      uint16_t *_compression_fmt)
578 {
579         return NT_STATUS_INVALID_DEVICE_REQUEST;
580 }
581
582 static NTSTATUS skel_set_compression(struct vfs_handle_struct *handle,
583                                      TALLOC_CTX *mem_ctx,
584                                      struct files_struct *fsp,
585                                      uint16_t compression_fmt)
586 {
587         return NT_STATUS_INVALID_DEVICE_REQUEST;
588 }
589
590 static NTSTATUS skel_streaminfo(struct vfs_handle_struct *handle,
591                                 struct files_struct *fsp,
592                                 const struct smb_filename *smb_fname,
593                                 TALLOC_CTX *mem_ctx,
594                                 unsigned int *num_streams,
595                                 struct stream_struct **streams)
596 {
597         return NT_STATUS_NOT_IMPLEMENTED;
598 }
599
600 static int skel_get_real_filename(struct vfs_handle_struct *handle,
601                                   const char *path,
602                                   const char *name,
603                                   TALLOC_CTX *mem_ctx, char **found_name)
604 {
605         errno = ENOSYS;
606         return -1;
607 }
608
609 static const char *skel_connectpath(struct vfs_handle_struct *handle,
610                                     const char *filename)
611 {
612         errno = ENOSYS;
613         return NULL;
614 }
615
616 static NTSTATUS skel_brl_lock_windows(struct vfs_handle_struct *handle,
617                                       struct byte_range_lock *br_lck,
618                                       struct lock_struct *plock,
619                                       bool blocking_lock)
620 {
621         return NT_STATUS_NOT_IMPLEMENTED;
622 }
623
624 static bool skel_brl_unlock_windows(struct vfs_handle_struct *handle,
625                                     struct messaging_context *msg_ctx,
626                                     struct byte_range_lock *br_lck,
627                                     const struct lock_struct *plock)
628 {
629         errno = ENOSYS;
630         return false;
631 }
632
633 static bool skel_brl_cancel_windows(struct vfs_handle_struct *handle,
634                                     struct byte_range_lock *br_lck,
635                                     struct lock_struct *plock)
636 {
637         errno = ENOSYS;
638         return false;
639 }
640
641 static bool skel_strict_lock(struct vfs_handle_struct *handle,
642                              struct files_struct *fsp,
643                              struct lock_struct *plock)
644 {
645         errno = ENOSYS;
646         return false;
647 }
648
649 static void skel_strict_unlock(struct vfs_handle_struct *handle,
650                                struct files_struct *fsp,
651                                struct lock_struct *plock)
652 {
653         ;
654 }
655
656 static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
657                                     const char *mapped_name,
658                                     enum vfs_translate_direction direction,
659                                     TALLOC_CTX *mem_ctx, char **pmapped_name)
660 {
661         return NT_STATUS_NOT_IMPLEMENTED;
662 }
663
664 static NTSTATUS skel_fsctl(struct vfs_handle_struct *handle,
665                            struct files_struct *fsp,
666                            TALLOC_CTX *ctx,
667                            uint32_t function,
668                            uint16_t req_flags,  /* Needed for UNICODE ... */
669                            const uint8_t *_in_data,
670                            uint32_t in_len,
671                            uint8_t **_out_data,
672                            uint32_t max_out_len, uint32_t *out_len)
673 {
674         return NT_STATUS_NOT_IMPLEMENTED;
675 }
676
677 static NTSTATUS skel_readdir_attr(struct vfs_handle_struct *handle,
678                                   const struct smb_filename *fname,
679                                   TALLOC_CTX *mem_ctx,
680                                   struct readdir_attr_data **pattr_data)
681 {
682         return NT_STATUS_NOT_IMPLEMENTED;
683 }
684
685 static NTSTATUS skel_get_dos_attributes(struct vfs_handle_struct *handle,
686                                 struct smb_filename *smb_fname,
687                                 uint32_t *dosmode)
688 {
689         return NT_STATUS_NOT_IMPLEMENTED;
690 }
691
692 static NTSTATUS skel_fget_dos_attributes(struct vfs_handle_struct *handle,
693                                 struct files_struct *fsp,
694                                 uint32_t *dosmode)
695 {
696         return NT_STATUS_NOT_IMPLEMENTED;
697 }
698
699 static NTSTATUS skel_set_dos_attributes(struct vfs_handle_struct *handle,
700                                 const struct smb_filename *smb_fname,
701                                 uint32_t dosmode)
702 {
703         return NT_STATUS_NOT_IMPLEMENTED;
704 }
705
706 static NTSTATUS skel_fset_dos_attributes(struct vfs_handle_struct *handle,
707                                 struct files_struct *fsp,
708                                 uint32_t dosmode)
709 {
710         return NT_STATUS_NOT_IMPLEMENTED;
711 }
712
713 static NTSTATUS skel_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
714                                  uint32_t security_info,
715                                  TALLOC_CTX *mem_ctx,
716                                  struct security_descriptor **ppdesc)
717 {
718         return NT_STATUS_NOT_IMPLEMENTED;
719 }
720
721 static NTSTATUS skel_get_nt_acl(vfs_handle_struct *handle,
722                                 const struct smb_filename *smb_fname,
723                                 uint32_t security_info,
724                                 TALLOC_CTX *mem_ctx,
725                                 struct security_descriptor **ppdesc)
726 {
727         return NT_STATUS_NOT_IMPLEMENTED;
728 }
729
730 static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
731                                  uint32_t security_info_sent,
732                                  const struct security_descriptor *psd)
733 {
734         return NT_STATUS_NOT_IMPLEMENTED;
735 }
736
737 static int skel_chmod_acl(vfs_handle_struct *handle,
738                         const struct smb_filename *smb_fname,
739                         mode_t mode)
740 {
741         errno = ENOSYS;
742         return -1;
743 }
744
745 static int skel_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp,
746                            mode_t mode)
747 {
748         errno = ENOSYS;
749         return -1;
750 }
751
752 static SMB_ACL_T skel_sys_acl_get_file(vfs_handle_struct *handle,
753                                        const struct smb_filename *smb_fname,
754                                        SMB_ACL_TYPE_T type,
755                                        TALLOC_CTX *mem_ctx)
756 {
757         errno = ENOSYS;
758         return (SMB_ACL_T) NULL;
759 }
760
761 static SMB_ACL_T skel_sys_acl_get_fd(vfs_handle_struct *handle,
762                                      files_struct *fsp, TALLOC_CTX *mem_ctx)
763 {
764         errno = ENOSYS;
765         return (SMB_ACL_T) NULL;
766 }
767
768 static int skel_sys_acl_blob_get_file(vfs_handle_struct *handle,
769                                 const struct smb_filename *smb_fname,
770                                 TALLOC_CTX *mem_ctx,
771                                 char **blob_description,
772                                 DATA_BLOB *blob)
773 {
774         errno = ENOSYS;
775         return -1;
776 }
777
778 static int skel_sys_acl_blob_get_fd(vfs_handle_struct *handle,
779                                     files_struct *fsp, TALLOC_CTX *mem_ctx,
780                                     char **blob_description, DATA_BLOB *blob)
781 {
782         errno = ENOSYS;
783         return -1;
784 }
785
786 static int skel_sys_acl_set_file(vfs_handle_struct *handle,
787                                 const struct smb_filename *smb_fname,
788                                 SMB_ACL_TYPE_T acltype,
789                                 SMB_ACL_T theacl)
790 {
791         errno = ENOSYS;
792         return -1;
793 }
794
795 static int skel_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
796                                SMB_ACL_T theacl)
797 {
798         errno = ENOSYS;
799         return -1;
800 }
801
802 static int skel_sys_acl_delete_def_file(vfs_handle_struct *handle,
803                                         const struct smb_filename *smb_fname)
804 {
805         errno = ENOSYS;
806         return -1;
807 }
808
809 static ssize_t skel_getxattr(vfs_handle_struct *handle,
810                                 const struct smb_filename *smb_fname,
811                                 const char *name,
812                                 void *value,
813                                 size_t size)
814 {
815         errno = ENOSYS;
816         return -1;
817 }
818
819 static ssize_t skel_fgetxattr(vfs_handle_struct *handle,
820                               struct files_struct *fsp, const char *name,
821                               void *value, size_t size)
822 {
823         errno = ENOSYS;
824         return -1;
825 }
826
827 static ssize_t skel_listxattr(vfs_handle_struct *handle,
828                                 const struct smb_filename *smb_fname,
829                                 char *list,
830                                 size_t size)
831 {
832         errno = ENOSYS;
833         return -1;
834 }
835
836 static ssize_t skel_flistxattr(vfs_handle_struct *handle,
837                                struct files_struct *fsp, char *list,
838                                size_t size)
839 {
840         errno = ENOSYS;
841         return -1;
842 }
843
844 static int skel_removexattr(vfs_handle_struct *handle,
845                         const struct smb_filename *smb_fname,
846                         const char *name)
847 {
848         errno = ENOSYS;
849         return -1;
850 }
851
852 static int skel_fremovexattr(vfs_handle_struct *handle,
853                              struct files_struct *fsp, const char *name)
854 {
855         errno = ENOSYS;
856         return -1;
857         return SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
858 }
859
860 static int skel_setxattr(vfs_handle_struct *handle,
861                         const struct smb_filename *smb_fname,
862                         const char *name,
863                         const void *value,
864                         size_t size,
865                         int flags)
866 {
867         errno = ENOSYS;
868         return -1;
869 }
870
871 static int skel_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp,
872                           const char *name, const void *value, size_t size,
873                           int flags)
874 {
875         errno = ENOSYS;
876         return -1;
877 }
878
879 static bool skel_aio_force(struct vfs_handle_struct *handle,
880                            struct files_struct *fsp)
881 {
882         errno = ENOSYS;
883         return false;
884 }
885
886 /* VFS operations structure */
887
888 struct vfs_fn_pointers skel_opaque_fns = {
889         /* Disk operations */
890
891         .connect_fn = skel_connect,
892         .disconnect_fn = skel_disconnect,
893         .disk_free_fn = skel_disk_free,
894         .get_quota_fn = skel_get_quota,
895         .set_quota_fn = skel_set_quota,
896         .get_shadow_copy_data_fn = skel_get_shadow_copy_data,
897         .statvfs_fn = skel_statvfs,
898         .fs_capabilities_fn = skel_fs_capabilities,
899         .get_dfs_referrals_fn = skel_get_dfs_referrals,
900         .snap_check_path_fn = skel_snap_check_path,
901         .snap_create_fn = skel_snap_create,
902         .snap_delete_fn = skel_snap_delete,
903
904         /* Directory operations */
905
906         .opendir_fn = skel_opendir,
907         .fdopendir_fn = skel_fdopendir,
908         .readdir_fn = skel_readdir,
909         .seekdir_fn = skel_seekdir,
910         .telldir_fn = skel_telldir,
911         .rewind_dir_fn = skel_rewind_dir,
912         .mkdir_fn = skel_mkdir,
913         .rmdir_fn = skel_rmdir,
914         .closedir_fn = skel_closedir,
915         .init_search_op_fn = skel_init_search_op,
916
917         /* File operations */
918
919         .open_fn = skel_open,
920         .create_file_fn = skel_create_file,
921         .close_fn = skel_close_fn,
922         .read_fn = skel_vfs_read,
923         .pread_fn = skel_pread,
924         .pread_send_fn = skel_pread_send,
925         .pread_recv_fn = skel_pread_recv,
926         .write_fn = skel_write,
927         .pwrite_fn = skel_pwrite,
928         .pwrite_send_fn = skel_pwrite_send,
929         .pwrite_recv_fn = skel_pwrite_recv,
930         .lseek_fn = skel_lseek,
931         .sendfile_fn = skel_sendfile,
932         .recvfile_fn = skel_recvfile,
933         .rename_fn = skel_rename,
934         .fsync_fn = skel_fsync,
935         .fsync_send_fn = skel_fsync_send,
936         .fsync_recv_fn = skel_fsync_recv,
937         .stat_fn = skel_stat,
938         .fstat_fn = skel_fstat,
939         .lstat_fn = skel_lstat,
940         .get_alloc_size_fn = skel_get_alloc_size,
941         .unlink_fn = skel_unlink,
942         .chmod_fn = skel_chmod,
943         .fchmod_fn = skel_fchmod,
944         .chown_fn = skel_chown,
945         .fchown_fn = skel_fchown,
946         .lchown_fn = skel_lchown,
947         .chdir_fn = skel_chdir,
948         .getwd_fn = skel_getwd,
949         .ntimes_fn = skel_ntimes,
950         .ftruncate_fn = skel_ftruncate,
951         .fallocate_fn = skel_fallocate,
952         .lock_fn = skel_lock,
953         .kernel_flock_fn = skel_kernel_flock,
954         .linux_setlease_fn = skel_linux_setlease,
955         .getlock_fn = skel_getlock,
956         .symlink_fn = skel_symlink,
957         .readlink_fn = skel_vfs_readlink,
958         .link_fn = skel_link,
959         .mknod_fn = skel_mknod,
960         .realpath_fn = skel_realpath,
961         .chflags_fn = skel_chflags,
962         .file_id_create_fn = skel_file_id_create,
963         .copy_chunk_send_fn = skel_copy_chunk_send,
964         .copy_chunk_recv_fn = skel_copy_chunk_recv,
965         .get_compression_fn = skel_get_compression,
966         .set_compression_fn = skel_set_compression,
967
968         .streaminfo_fn = skel_streaminfo,
969         .get_real_filename_fn = skel_get_real_filename,
970         .connectpath_fn = skel_connectpath,
971         .brl_lock_windows_fn = skel_brl_lock_windows,
972         .brl_unlock_windows_fn = skel_brl_unlock_windows,
973         .brl_cancel_windows_fn = skel_brl_cancel_windows,
974         .strict_lock_fn = skel_strict_lock,
975         .strict_unlock_fn = skel_strict_unlock,
976         .translate_name_fn = skel_translate_name,
977         .fsctl_fn = skel_fsctl,
978         .readdir_attr_fn = skel_readdir_attr,
979
980         /* DOS attributes. */
981         .get_dos_attributes_fn = skel_get_dos_attributes,
982         .fget_dos_attributes_fn = skel_fget_dos_attributes,
983         .set_dos_attributes_fn = skel_set_dos_attributes,
984         .fset_dos_attributes_fn = skel_fset_dos_attributes,
985
986         /* NT ACL operations. */
987
988         .fget_nt_acl_fn = skel_fget_nt_acl,
989         .get_nt_acl_fn = skel_get_nt_acl,
990         .fset_nt_acl_fn = skel_fset_nt_acl,
991
992         /* POSIX ACL operations. */
993
994         .chmod_acl_fn = skel_chmod_acl,
995         .fchmod_acl_fn = skel_fchmod_acl,
996
997         .sys_acl_get_file_fn = skel_sys_acl_get_file,
998         .sys_acl_get_fd_fn = skel_sys_acl_get_fd,
999         .sys_acl_blob_get_file_fn = skel_sys_acl_blob_get_file,
1000         .sys_acl_blob_get_fd_fn = skel_sys_acl_blob_get_fd,
1001         .sys_acl_set_file_fn = skel_sys_acl_set_file,
1002         .sys_acl_set_fd_fn = skel_sys_acl_set_fd,
1003         .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file,
1004
1005         /* EA operations. */
1006         .getxattr_fn = skel_getxattr,
1007         .fgetxattr_fn = skel_fgetxattr,
1008         .listxattr_fn = skel_listxattr,
1009         .flistxattr_fn = skel_flistxattr,
1010         .removexattr_fn = skel_removexattr,
1011         .fremovexattr_fn = skel_fremovexattr,
1012         .setxattr_fn = skel_setxattr,
1013         .fsetxattr_fn = skel_fsetxattr,
1014
1015         /* aio operations */
1016         .aio_force_fn = skel_aio_force,
1017 };
1018
1019 static_decl_vfs;
1020 NTSTATUS vfs_skel_opaque_init(TALLOC_CTX *ctx)
1021 {
1022         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_opaque",
1023                                 &skel_opaque_fns);
1024 }