s3: VFS: Change SMB_VFS_SYMLINK to use const struct smb_filename * instead of const...
[sfrench/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,
480                         const char *link_contents,
481                         const struct smb_filename *new_smb_fname)
482 {
483         errno = ENOSYS;
484         return -1;
485 }
486
487 static int skel_vfs_readlink(vfs_handle_struct *handle,
488                         const struct smb_filename *smb_fname,
489                         char *buf,
490                         size_t bufsiz)
491 {
492         errno = ENOSYS;
493         return -1;
494 }
495
496 static int skel_link(vfs_handle_struct *handle,
497                         const struct smb_filename *old_smb_fname,
498                         const struct smb_filename *new_smb_fname)
499 {
500         errno = ENOSYS;
501         return -1;
502 }
503
504 static int skel_mknod(vfs_handle_struct *handle,
505                         const struct smb_filename *smb_fname,
506                         mode_t mode,
507                         SMB_DEV_T dev)
508 {
509         errno = ENOSYS;
510         return -1;
511 }
512
513 static char *skel_realpath(vfs_handle_struct *handle, const char *path)
514 {
515         errno = ENOSYS;
516         return NULL;
517 }
518
519 static int skel_chflags(vfs_handle_struct *handle,
520                         const struct smb_filename *smb_fname,
521                         uint flags)
522 {
523         errno = ENOSYS;
524         return -1;
525 }
526
527 static struct file_id skel_file_id_create(vfs_handle_struct *handle,
528                                           const SMB_STRUCT_STAT *sbuf)
529 {
530         struct file_id id;
531         ZERO_STRUCT(id);
532         errno = ENOSYS;
533         return id;
534 }
535
536 struct skel_cc_state {
537         uint64_t unused;
538 };
539 static struct tevent_req *skel_copy_chunk_send(struct vfs_handle_struct *handle,
540                                                TALLOC_CTX *mem_ctx,
541                                                struct tevent_context *ev,
542                                                struct files_struct *src_fsp,
543                                                off_t src_off,
544                                                struct files_struct *dest_fsp,
545                                                off_t dest_off,
546                                                off_t num,
547                                                uint32_t flags)
548 {
549         struct tevent_req *req;
550         struct skel_cc_state *cc_state;
551
552         req = tevent_req_create(mem_ctx, &cc_state, struct skel_cc_state);
553         if (req == NULL) {
554                 return NULL;
555         }
556
557         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
558         return tevent_req_post(req, ev);
559 }
560
561 static NTSTATUS skel_copy_chunk_recv(struct vfs_handle_struct *handle,
562                                      struct tevent_req *req,
563                                      off_t *copied)
564 {
565         NTSTATUS status;
566
567         if (tevent_req_is_nterror(req, &status)) {
568                 tevent_req_received(req);
569                 return status;
570         }
571         tevent_req_received(req);
572
573         return NT_STATUS_OK;
574 }
575
576 static NTSTATUS skel_get_compression(struct vfs_handle_struct *handle,
577                                      TALLOC_CTX *mem_ctx,
578                                      struct files_struct *fsp,
579                                      struct smb_filename *smb_fname,
580                                      uint16_t *_compression_fmt)
581 {
582         return NT_STATUS_INVALID_DEVICE_REQUEST;
583 }
584
585 static NTSTATUS skel_set_compression(struct vfs_handle_struct *handle,
586                                      TALLOC_CTX *mem_ctx,
587                                      struct files_struct *fsp,
588                                      uint16_t compression_fmt)
589 {
590         return NT_STATUS_INVALID_DEVICE_REQUEST;
591 }
592
593 static NTSTATUS skel_streaminfo(struct vfs_handle_struct *handle,
594                                 struct files_struct *fsp,
595                                 const struct smb_filename *smb_fname,
596                                 TALLOC_CTX *mem_ctx,
597                                 unsigned int *num_streams,
598                                 struct stream_struct **streams)
599 {
600         return NT_STATUS_NOT_IMPLEMENTED;
601 }
602
603 static int skel_get_real_filename(struct vfs_handle_struct *handle,
604                                   const char *path,
605                                   const char *name,
606                                   TALLOC_CTX *mem_ctx, char **found_name)
607 {
608         errno = ENOSYS;
609         return -1;
610 }
611
612 static const char *skel_connectpath(struct vfs_handle_struct *handle,
613                                     const char *filename)
614 {
615         errno = ENOSYS;
616         return NULL;
617 }
618
619 static NTSTATUS skel_brl_lock_windows(struct vfs_handle_struct *handle,
620                                       struct byte_range_lock *br_lck,
621                                       struct lock_struct *plock,
622                                       bool blocking_lock)
623 {
624         return NT_STATUS_NOT_IMPLEMENTED;
625 }
626
627 static bool skel_brl_unlock_windows(struct vfs_handle_struct *handle,
628                                     struct messaging_context *msg_ctx,
629                                     struct byte_range_lock *br_lck,
630                                     const struct lock_struct *plock)
631 {
632         errno = ENOSYS;
633         return false;
634 }
635
636 static bool skel_brl_cancel_windows(struct vfs_handle_struct *handle,
637                                     struct byte_range_lock *br_lck,
638                                     struct lock_struct *plock)
639 {
640         errno = ENOSYS;
641         return false;
642 }
643
644 static bool skel_strict_lock(struct vfs_handle_struct *handle,
645                              struct files_struct *fsp,
646                              struct lock_struct *plock)
647 {
648         errno = ENOSYS;
649         return false;
650 }
651
652 static void skel_strict_unlock(struct vfs_handle_struct *handle,
653                                struct files_struct *fsp,
654                                struct lock_struct *plock)
655 {
656         ;
657 }
658
659 static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
660                                     const char *mapped_name,
661                                     enum vfs_translate_direction direction,
662                                     TALLOC_CTX *mem_ctx, char **pmapped_name)
663 {
664         return NT_STATUS_NOT_IMPLEMENTED;
665 }
666
667 static NTSTATUS skel_fsctl(struct vfs_handle_struct *handle,
668                            struct files_struct *fsp,
669                            TALLOC_CTX *ctx,
670                            uint32_t function,
671                            uint16_t req_flags,  /* Needed for UNICODE ... */
672                            const uint8_t *_in_data,
673                            uint32_t in_len,
674                            uint8_t **_out_data,
675                            uint32_t max_out_len, uint32_t *out_len)
676 {
677         return NT_STATUS_NOT_IMPLEMENTED;
678 }
679
680 static NTSTATUS skel_readdir_attr(struct vfs_handle_struct *handle,
681                                   const struct smb_filename *fname,
682                                   TALLOC_CTX *mem_ctx,
683                                   struct readdir_attr_data **pattr_data)
684 {
685         return NT_STATUS_NOT_IMPLEMENTED;
686 }
687
688 static NTSTATUS skel_get_dos_attributes(struct vfs_handle_struct *handle,
689                                 struct smb_filename *smb_fname,
690                                 uint32_t *dosmode)
691 {
692         return NT_STATUS_NOT_IMPLEMENTED;
693 }
694
695 static NTSTATUS skel_fget_dos_attributes(struct vfs_handle_struct *handle,
696                                 struct files_struct *fsp,
697                                 uint32_t *dosmode)
698 {
699         return NT_STATUS_NOT_IMPLEMENTED;
700 }
701
702 static NTSTATUS skel_set_dos_attributes(struct vfs_handle_struct *handle,
703                                 const struct smb_filename *smb_fname,
704                                 uint32_t dosmode)
705 {
706         return NT_STATUS_NOT_IMPLEMENTED;
707 }
708
709 static NTSTATUS skel_fset_dos_attributes(struct vfs_handle_struct *handle,
710                                 struct files_struct *fsp,
711                                 uint32_t dosmode)
712 {
713         return NT_STATUS_NOT_IMPLEMENTED;
714 }
715
716 static NTSTATUS skel_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
717                                  uint32_t security_info,
718                                  TALLOC_CTX *mem_ctx,
719                                  struct security_descriptor **ppdesc)
720 {
721         return NT_STATUS_NOT_IMPLEMENTED;
722 }
723
724 static NTSTATUS skel_get_nt_acl(vfs_handle_struct *handle,
725                                 const struct smb_filename *smb_fname,
726                                 uint32_t security_info,
727                                 TALLOC_CTX *mem_ctx,
728                                 struct security_descriptor **ppdesc)
729 {
730         return NT_STATUS_NOT_IMPLEMENTED;
731 }
732
733 static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
734                                  uint32_t security_info_sent,
735                                  const struct security_descriptor *psd)
736 {
737         return NT_STATUS_NOT_IMPLEMENTED;
738 }
739
740 static int skel_chmod_acl(vfs_handle_struct *handle,
741                         const struct smb_filename *smb_fname,
742                         mode_t mode)
743 {
744         errno = ENOSYS;
745         return -1;
746 }
747
748 static int skel_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp,
749                            mode_t mode)
750 {
751         errno = ENOSYS;
752         return -1;
753 }
754
755 static SMB_ACL_T skel_sys_acl_get_file(vfs_handle_struct *handle,
756                                        const struct smb_filename *smb_fname,
757                                        SMB_ACL_TYPE_T type,
758                                        TALLOC_CTX *mem_ctx)
759 {
760         errno = ENOSYS;
761         return (SMB_ACL_T) NULL;
762 }
763
764 static SMB_ACL_T skel_sys_acl_get_fd(vfs_handle_struct *handle,
765                                      files_struct *fsp, TALLOC_CTX *mem_ctx)
766 {
767         errno = ENOSYS;
768         return (SMB_ACL_T) NULL;
769 }
770
771 static int skel_sys_acl_blob_get_file(vfs_handle_struct *handle,
772                                 const struct smb_filename *smb_fname,
773                                 TALLOC_CTX *mem_ctx,
774                                 char **blob_description,
775                                 DATA_BLOB *blob)
776 {
777         errno = ENOSYS;
778         return -1;
779 }
780
781 static int skel_sys_acl_blob_get_fd(vfs_handle_struct *handle,
782                                     files_struct *fsp, TALLOC_CTX *mem_ctx,
783                                     char **blob_description, DATA_BLOB *blob)
784 {
785         errno = ENOSYS;
786         return -1;
787 }
788
789 static int skel_sys_acl_set_file(vfs_handle_struct *handle,
790                                 const struct smb_filename *smb_fname,
791                                 SMB_ACL_TYPE_T acltype,
792                                 SMB_ACL_T theacl)
793 {
794         errno = ENOSYS;
795         return -1;
796 }
797
798 static int skel_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
799                                SMB_ACL_T theacl)
800 {
801         errno = ENOSYS;
802         return -1;
803 }
804
805 static int skel_sys_acl_delete_def_file(vfs_handle_struct *handle,
806                                         const struct smb_filename *smb_fname)
807 {
808         errno = ENOSYS;
809         return -1;
810 }
811
812 static ssize_t skel_getxattr(vfs_handle_struct *handle,
813                                 const struct smb_filename *smb_fname,
814                                 const char *name,
815                                 void *value,
816                                 size_t size)
817 {
818         errno = ENOSYS;
819         return -1;
820 }
821
822 static ssize_t skel_fgetxattr(vfs_handle_struct *handle,
823                               struct files_struct *fsp, const char *name,
824                               void *value, size_t size)
825 {
826         errno = ENOSYS;
827         return -1;
828 }
829
830 static ssize_t skel_listxattr(vfs_handle_struct *handle,
831                                 const struct smb_filename *smb_fname,
832                                 char *list,
833                                 size_t size)
834 {
835         errno = ENOSYS;
836         return -1;
837 }
838
839 static ssize_t skel_flistxattr(vfs_handle_struct *handle,
840                                struct files_struct *fsp, char *list,
841                                size_t size)
842 {
843         errno = ENOSYS;
844         return -1;
845 }
846
847 static int skel_removexattr(vfs_handle_struct *handle,
848                         const struct smb_filename *smb_fname,
849                         const char *name)
850 {
851         errno = ENOSYS;
852         return -1;
853 }
854
855 static int skel_fremovexattr(vfs_handle_struct *handle,
856                              struct files_struct *fsp, const char *name)
857 {
858         errno = ENOSYS;
859         return -1;
860         return SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
861 }
862
863 static int skel_setxattr(vfs_handle_struct *handle,
864                         const struct smb_filename *smb_fname,
865                         const char *name,
866                         const void *value,
867                         size_t size,
868                         int flags)
869 {
870         errno = ENOSYS;
871         return -1;
872 }
873
874 static int skel_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp,
875                           const char *name, const void *value, size_t size,
876                           int flags)
877 {
878         errno = ENOSYS;
879         return -1;
880 }
881
882 static bool skel_aio_force(struct vfs_handle_struct *handle,
883                            struct files_struct *fsp)
884 {
885         errno = ENOSYS;
886         return false;
887 }
888
889 /* VFS operations structure */
890
891 struct vfs_fn_pointers skel_opaque_fns = {
892         /* Disk operations */
893
894         .connect_fn = skel_connect,
895         .disconnect_fn = skel_disconnect,
896         .disk_free_fn = skel_disk_free,
897         .get_quota_fn = skel_get_quota,
898         .set_quota_fn = skel_set_quota,
899         .get_shadow_copy_data_fn = skel_get_shadow_copy_data,
900         .statvfs_fn = skel_statvfs,
901         .fs_capabilities_fn = skel_fs_capabilities,
902         .get_dfs_referrals_fn = skel_get_dfs_referrals,
903         .snap_check_path_fn = skel_snap_check_path,
904         .snap_create_fn = skel_snap_create,
905         .snap_delete_fn = skel_snap_delete,
906
907         /* Directory operations */
908
909         .opendir_fn = skel_opendir,
910         .fdopendir_fn = skel_fdopendir,
911         .readdir_fn = skel_readdir,
912         .seekdir_fn = skel_seekdir,
913         .telldir_fn = skel_telldir,
914         .rewind_dir_fn = skel_rewind_dir,
915         .mkdir_fn = skel_mkdir,
916         .rmdir_fn = skel_rmdir,
917         .closedir_fn = skel_closedir,
918         .init_search_op_fn = skel_init_search_op,
919
920         /* File operations */
921
922         .open_fn = skel_open,
923         .create_file_fn = skel_create_file,
924         .close_fn = skel_close_fn,
925         .read_fn = skel_vfs_read,
926         .pread_fn = skel_pread,
927         .pread_send_fn = skel_pread_send,
928         .pread_recv_fn = skel_pread_recv,
929         .write_fn = skel_write,
930         .pwrite_fn = skel_pwrite,
931         .pwrite_send_fn = skel_pwrite_send,
932         .pwrite_recv_fn = skel_pwrite_recv,
933         .lseek_fn = skel_lseek,
934         .sendfile_fn = skel_sendfile,
935         .recvfile_fn = skel_recvfile,
936         .rename_fn = skel_rename,
937         .fsync_fn = skel_fsync,
938         .fsync_send_fn = skel_fsync_send,
939         .fsync_recv_fn = skel_fsync_recv,
940         .stat_fn = skel_stat,
941         .fstat_fn = skel_fstat,
942         .lstat_fn = skel_lstat,
943         .get_alloc_size_fn = skel_get_alloc_size,
944         .unlink_fn = skel_unlink,
945         .chmod_fn = skel_chmod,
946         .fchmod_fn = skel_fchmod,
947         .chown_fn = skel_chown,
948         .fchown_fn = skel_fchown,
949         .lchown_fn = skel_lchown,
950         .chdir_fn = skel_chdir,
951         .getwd_fn = skel_getwd,
952         .ntimes_fn = skel_ntimes,
953         .ftruncate_fn = skel_ftruncate,
954         .fallocate_fn = skel_fallocate,
955         .lock_fn = skel_lock,
956         .kernel_flock_fn = skel_kernel_flock,
957         .linux_setlease_fn = skel_linux_setlease,
958         .getlock_fn = skel_getlock,
959         .symlink_fn = skel_symlink,
960         .readlink_fn = skel_vfs_readlink,
961         .link_fn = skel_link,
962         .mknod_fn = skel_mknod,
963         .realpath_fn = skel_realpath,
964         .chflags_fn = skel_chflags,
965         .file_id_create_fn = skel_file_id_create,
966         .copy_chunk_send_fn = skel_copy_chunk_send,
967         .copy_chunk_recv_fn = skel_copy_chunk_recv,
968         .get_compression_fn = skel_get_compression,
969         .set_compression_fn = skel_set_compression,
970
971         .streaminfo_fn = skel_streaminfo,
972         .get_real_filename_fn = skel_get_real_filename,
973         .connectpath_fn = skel_connectpath,
974         .brl_lock_windows_fn = skel_brl_lock_windows,
975         .brl_unlock_windows_fn = skel_brl_unlock_windows,
976         .brl_cancel_windows_fn = skel_brl_cancel_windows,
977         .strict_lock_fn = skel_strict_lock,
978         .strict_unlock_fn = skel_strict_unlock,
979         .translate_name_fn = skel_translate_name,
980         .fsctl_fn = skel_fsctl,
981         .readdir_attr_fn = skel_readdir_attr,
982
983         /* DOS attributes. */
984         .get_dos_attributes_fn = skel_get_dos_attributes,
985         .fget_dos_attributes_fn = skel_fget_dos_attributes,
986         .set_dos_attributes_fn = skel_set_dos_attributes,
987         .fset_dos_attributes_fn = skel_fset_dos_attributes,
988
989         /* NT ACL operations. */
990
991         .fget_nt_acl_fn = skel_fget_nt_acl,
992         .get_nt_acl_fn = skel_get_nt_acl,
993         .fset_nt_acl_fn = skel_fset_nt_acl,
994
995         /* POSIX ACL operations. */
996
997         .chmod_acl_fn = skel_chmod_acl,
998         .fchmod_acl_fn = skel_fchmod_acl,
999
1000         .sys_acl_get_file_fn = skel_sys_acl_get_file,
1001         .sys_acl_get_fd_fn = skel_sys_acl_get_fd,
1002         .sys_acl_blob_get_file_fn = skel_sys_acl_blob_get_file,
1003         .sys_acl_blob_get_fd_fn = skel_sys_acl_blob_get_fd,
1004         .sys_acl_set_file_fn = skel_sys_acl_set_file,
1005         .sys_acl_set_fd_fn = skel_sys_acl_set_fd,
1006         .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file,
1007
1008         /* EA operations. */
1009         .getxattr_fn = skel_getxattr,
1010         .fgetxattr_fn = skel_fgetxattr,
1011         .listxattr_fn = skel_listxattr,
1012         .flistxattr_fn = skel_flistxattr,
1013         .removexattr_fn = skel_removexattr,
1014         .fremovexattr_fn = skel_fremovexattr,
1015         .setxattr_fn = skel_setxattr,
1016         .fsetxattr_fn = skel_fsetxattr,
1017
1018         /* aio operations */
1019         .aio_force_fn = skel_aio_force,
1020 };
1021
1022 static_decl_vfs;
1023 NTSTATUS vfs_skel_opaque_init(TALLOC_CTX *ctx)
1024 {
1025         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_opaque",
1026                                 &skel_opaque_fns);
1027 }