Add fdopendir to the VFS. We will use this to reuse a directory fd already open by...
[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
25 #include "includes.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, const char *user)    
36 {
37         errno = ENOSYS;
38         return -1;
39 }
40
41 static void skel_disconnect(vfs_handle_struct *handle)
42 {
43         ;
44 }
45
46 static uint64_t skel_disk_free(vfs_handle_struct *handle,  const char *path,
47         bool small_query, uint64_t *bsize,
48         uint64_t *dfree, uint64_t *dsize)
49 {
50         *bsize = 0;
51         *dfree = 0;
52         *dsize = 0;
53         return 0;
54 }
55
56 static int skel_get_quota(vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
57 {
58         errno = ENOSYS;
59         return -1;
60 }
61
62 static int skel_set_quota(vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq)
63 {
64         errno = ENOSYS;
65         return -1;
66 }
67
68 static int skel_get_shadow_copy_data(vfs_handle_struct *handle, files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, bool labels)
69 {
70         errno = ENOSYS;
71         return -1;
72 }
73
74 static int skel_statvfs(struct vfs_handle_struct *handle, const char *path, struct vfs_statvfs_struct *statbuf)
75 {
76         errno = ENOSYS;
77         return -1;
78 }
79
80 static uint32_t skel_fs_capabilities(struct vfs_handle_struct *handle, enum timestamp_set_resolution *p_ts_res)
81 {
82         return 0;
83 }
84
85 static SMB_STRUCT_DIR *skel_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
86 {
87         return NULL;
88 }
89
90 static SMB_STRUCT_DIR *skel_fdopendir(vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attr)
91 {
92         return NULL;
93 }
94
95 static SMB_STRUCT_DIRENT *skel_readdir(vfs_handle_struct *handle,
96                                        SMB_STRUCT_DIR *dirp,
97                                        SMB_STRUCT_STAT *sbuf)
98 {
99         return NULL;
100 }
101
102 static void skel_seekdir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp, long offset)
103 {
104         ;
105 }
106
107 static long skel_telldir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
108 {
109         return (long)-1;
110 }
111
112 static void skel_rewind_dir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
113 {
114         ;
115 }
116
117 static int skel_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
118 {
119         errno = ENOSYS;
120         return -1;
121 }
122
123 static int skel_rmdir(vfs_handle_struct *handle,  const char *path)
124 {
125         errno = ENOSYS;
126         return -1;
127 }
128
129 static int skel_closedir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dir)
130 {
131         errno = ENOSYS;
132         return -1;
133 }
134
135 static void skel_init_search_op(struct vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
136 {
137         ;
138 }
139
140 static int skel_open(vfs_handle_struct *handle, struct smb_filename *smb_fname,
141                      files_struct *fsp, int flags, mode_t mode)
142 {
143         errno = ENOSYS;
144         return -1;
145 }
146
147 static NTSTATUS skel_create_file(struct vfs_handle_struct *handle,
148                                 struct smb_request *req,
149                                 uint16_t root_dir_fid,
150                                 struct smb_filename *smb_fname,
151                                 uint32_t access_mask,
152                                 uint32_t share_access,
153                                 uint32_t create_disposition,
154                                 uint32_t create_options,
155                                 uint32_t file_attributes,
156                                 uint32_t oplock_request,
157                                 uint64_t allocation_size,
158                                 uint32_t private_flags,
159                                 struct security_descriptor *sd,
160                                 struct ea_list *ea_list,
161                                 files_struct **result,
162                                 int *pinfo)
163 {
164         return NT_STATUS_NOT_IMPLEMENTED;
165 }
166
167 static int skel_close_fn(vfs_handle_struct *handle, files_struct *fsp)
168 {
169         errno = ENOSYS;
170         return -1;
171 }
172
173 static ssize_t skel_vfs_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
174 {
175         errno = ENOSYS;
176         return -1;
177 }
178
179 static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, SMB_OFF_T offset)
180 {
181         errno = ENOSYS;
182         return -1;
183 }
184
185 static ssize_t skel_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
186 {
187         errno = ENOSYS;
188         return -1;
189 }
190
191 static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, SMB_OFF_T offset)
192 {
193         errno = ENOSYS;
194         return -1;
195 }
196
197 static SMB_OFF_T skel_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
198 {
199         errno = ENOSYS;
200         return (SMB_OFF_T)-1;
201 }
202
203 static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, SMB_OFF_T offset, size_t n)
204 {
205         errno = ENOSYS;
206         return -1;
207 }
208
209 static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t n)
210 {
211         errno = ENOSYS;
212         return -1;
213 }
214
215 static int skel_rename(vfs_handle_struct *handle,
216                        const struct smb_filename *smb_fname_src,
217                        const struct smb_filename *smb_fname_dst)
218 {
219         errno = ENOSYS;
220         return -1;
221 }
222
223 static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp)
224 {
225         errno = ENOSYS;
226         return -1;
227 }
228
229 static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
230 {
231         errno = ENOSYS;
232         return -1;
233 }
234
235 static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
236 {
237         errno = ENOSYS;
238         return -1;
239 }
240
241 static int skel_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
242 {
243         errno = ENOSYS;
244         return -1;
245 }
246
247 static uint64_t skel_get_alloc_size(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
248 {
249         errno = ENOSYS;
250         return -1;
251 }
252
253 static int skel_unlink(vfs_handle_struct *handle,
254                        const struct smb_filename *smb_fname)
255 {
256         errno = ENOSYS;
257         return -1;
258 }
259
260 static int skel_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
261 {
262         errno = ENOSYS;
263         return -1;
264 }
265
266 static int skel_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
267 {
268         errno = ENOSYS;
269         return -1;
270 }
271
272 static int skel_chown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
273 {
274         errno = ENOSYS;
275         return -1;
276 }
277
278 static int skel_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
279 {
280         errno = ENOSYS;
281         return -1;
282 }
283
284 static int skel_lchown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
285 {
286         errno = ENOSYS;
287         return -1;
288 }
289
290 static int skel_chdir(vfs_handle_struct *handle,  const char *path)
291 {
292         errno = ENOSYS;
293         return -1;
294 }
295
296 static char *skel_getwd(vfs_handle_struct *handle,  char *buf)
297 {
298         errno = ENOSYS;
299         return NULL;
300 }
301
302 static int skel_ntimes(vfs_handle_struct *handle,
303                        const struct smb_filename *smb_fname,
304                        struct smb_file_time *ft)
305 {
306         errno = ENOSYS;
307         return -1;
308 }
309
310 static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset)
311 {
312         errno = ENOSYS;
313         return -1;
314 }
315
316 static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
317                         enum vfs_fallocate_mode mode,
318                         SMB_OFF_T offset, SMB_OFF_T len)
319 {
320         errno = ENOSYS;
321         return -1;
322 }
323
324 static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
325 {
326         errno = ENOSYS;
327         return false;
328 }
329
330 static int skel_kernel_flock(struct vfs_handle_struct *handle, struct files_struct *fsp, uint32 share_mode, uint32 access_mask)
331 {
332         errno = ENOSYS;
333         return -1;
334 }
335
336 static int skel_linux_setlease(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype)
337 {
338         errno = ENOSYS;
339         return -1;
340 }
341
342 static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
343 {
344         errno = ENOSYS;
345         return false;
346 }
347
348 static int skel_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
349 {
350         errno = ENOSYS;
351         return -1;
352 }
353
354 static int skel_vfs_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
355 {
356         errno = ENOSYS;
357         return -1;
358 }
359
360 static int skel_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
361 {
362         errno = ENOSYS;
363         return -1;
364 }
365
366 static int skel_mknod(vfs_handle_struct *handle,  const char *path, mode_t mode, SMB_DEV_T dev)
367 {
368         errno = ENOSYS;
369         return -1;
370 }
371
372 static char *skel_realpath(vfs_handle_struct *handle,  const char *path)
373 {
374         errno = ENOSYS;
375         return NULL;
376 }
377
378 static NTSTATUS skel_notify_watch(struct vfs_handle_struct *handle,
379             struct sys_notify_context *ctx, struct notify_entry *e,
380             void (*callback)(struct sys_notify_context *ctx, void *private_data, struct notify_event *ev),
381             void *private_data, void *handle_p)
382 {
383         return NT_STATUS_NOT_IMPLEMENTED;
384 }
385
386 static int skel_chflags(vfs_handle_struct *handle,  const char *path, uint flags)
387 {
388         errno = ENOSYS;
389         return -1;
390 }
391
392 static struct file_id skel_file_id_create(vfs_handle_struct *handle,
393                                           const SMB_STRUCT_STAT *sbuf)
394 {
395         struct file_id id;
396         ZERO_STRUCT(id);
397         errno = ENOSYS;
398         return id;
399 }
400
401 static NTSTATUS skel_streaminfo(struct vfs_handle_struct *handle,
402                                 struct files_struct *fsp,
403                                 const char *fname,
404                                 TALLOC_CTX *mem_ctx,
405                                 unsigned int *num_streams,
406                                 struct stream_struct **streams)
407 {
408         return NT_STATUS_NOT_IMPLEMENTED;
409 }
410
411 static int skel_get_real_filename(struct vfs_handle_struct *handle,
412                                 const char *path,
413                                 const char *name,
414                                 TALLOC_CTX *mem_ctx,
415                                 char **found_name)
416 {
417         errno = ENOSYS;
418         return -1;
419 }
420
421 static const char *skel_connectpath(struct vfs_handle_struct *handle,
422                                 const char *filename)
423 {
424         errno = ENOSYS;
425         return NULL;
426 }
427
428 static NTSTATUS skel_brl_lock_windows(struct vfs_handle_struct *handle,
429                                 struct byte_range_lock *br_lck,
430                                 struct lock_struct *plock,
431                                 bool blocking_lock,
432                                 struct blocking_lock_record *blr)
433 {
434         return NT_STATUS_NOT_IMPLEMENTED;
435 }
436
437 static bool skel_brl_unlock_windows(struct vfs_handle_struct *handle,
438                                 struct messaging_context *msg_ctx,
439                                 struct byte_range_lock *br_lck,
440                                 const struct lock_struct *plock)
441 {
442         errno = ENOSYS;
443         return false;
444 }
445
446 static bool skel_brl_cancel_windows(struct vfs_handle_struct *handle,
447                                 struct byte_range_lock *br_lck,
448                                 struct lock_struct *plock,
449                                 struct blocking_lock_record *blr)
450 {
451         errno = ENOSYS;
452         return false;
453 }
454
455 static bool skel_strict_lock(struct vfs_handle_struct *handle,
456                                 struct files_struct *fsp,
457                                 struct lock_struct *plock)
458 {
459         errno = ENOSYS;
460         return false;
461 }
462
463 static void skel_strict_unlock(struct vfs_handle_struct *handle,
464                                 struct files_struct *fsp,
465                                 struct lock_struct *plock)
466 {
467         ;
468 }
469
470 static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
471                                 const char *mapped_name,
472                                 enum vfs_translate_direction direction,
473                                 TALLOC_CTX *mem_ctx,
474                                 char **pmapped_name)
475 {
476         return NT_STATUS_NOT_IMPLEMENTED;
477 }
478
479 static NTSTATUS skel_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
480         uint32 security_info, SEC_DESC **ppdesc)
481 {
482         return NT_STATUS_NOT_IMPLEMENTED;
483 }
484
485 static NTSTATUS skel_get_nt_acl(vfs_handle_struct *handle,
486         const char *name, uint32 security_info, SEC_DESC **ppdesc)
487 {
488         return NT_STATUS_NOT_IMPLEMENTED;
489 }
490
491 static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
492         uint32 security_info_sent, const SEC_DESC *psd)
493 {
494         return NT_STATUS_NOT_IMPLEMENTED;
495 }
496
497 static int skel_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
498 {
499         errno = ENOSYS;
500         return -1;
501 }
502
503 static int skel_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
504 {
505         errno = ENOSYS;
506         return -1;
507 }
508
509 static int skel_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
510 {
511         errno = ENOSYS;
512         return -1;
513 }
514
515 static int skel_sys_acl_get_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
516 {
517         errno = ENOSYS;
518         return -1;
519 }
520
521 static int skel_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
522 {
523         errno = ENOSYS;
524         return -1;
525 }
526
527 static void *skel_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
528 {
529         errno = ENOSYS;
530         return NULL;
531 }
532
533 static SMB_ACL_T skel_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
534 {
535         errno = ENOSYS;
536         return (SMB_ACL_T)NULL;
537 }
538
539 static SMB_ACL_T skel_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
540 {
541         errno = ENOSYS;
542         return (SMB_ACL_T)NULL;
543 }
544
545 static int skel_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
546 {
547         errno = ENOSYS;
548         return -1;
549 }
550
551 static int skel_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
552 {
553         errno = ENOSYS;
554         return -1;
555 }
556
557 static char *skel_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
558 {
559         errno = ENOSYS;
560         return NULL;
561 }
562
563 static SMB_ACL_T skel_sys_acl_init(vfs_handle_struct *handle,  int count)
564 {
565         errno = ENOSYS;
566         return (SMB_ACL_T)NULL;
567 }
568
569 static int skel_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
570 {
571         errno = ENOSYS;
572         return -1;
573 }
574
575 static int skel_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
576 {
577         errno = ENOSYS;
578         return -1;
579 }
580
581 static int skel_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
582 {
583         errno = ENOSYS;
584         return -1;
585 }
586
587 static int skel_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
588 {
589         errno = ENOSYS;
590         return -1;
591 }
592
593 static int skel_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
594 {
595         errno = ENOSYS;
596         return -1;
597 }
598
599 static int skel_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
600 {
601         errno = ENOSYS;
602         return -1;
603 }
604
605 static int skel_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
606 {
607         errno = ENOSYS;
608         return -1;
609 }
610
611 static int skel_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
612 {
613         errno = ENOSYS;
614         return -1;
615 }
616
617 static int skel_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
618 {
619         errno = ENOSYS;
620         return -1;
621 }
622
623 static int skel_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
624 {
625         errno = ENOSYS;
626         return -1;
627 }
628
629 static int skel_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
630 {
631         errno = ENOSYS;
632         return -1;
633 }
634
635 static int skel_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
636 {
637         errno = ENOSYS;
638         return -1;
639 }
640
641 static ssize_t skel_getxattr(vfs_handle_struct *handle, const char *path, const char *name, void *value, size_t size)
642 {
643         errno = ENOSYS;
644         return -1;
645 }
646
647 static ssize_t skel_lgetxattr(vfs_handle_struct *handle, const char *path, const char *name, void *value, size_t
648 size)
649 {
650         errno = ENOSYS;
651         return -1;
652 }
653
654 static ssize_t skel_fgetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
655 {
656         errno = ENOSYS;
657         return -1;
658 }
659
660 static ssize_t skel_listxattr(vfs_handle_struct *handle, const char *path, char *list, size_t size)
661 {
662         errno = ENOSYS;
663         return -1;
664 }
665
666 static ssize_t skel_llistxattr(vfs_handle_struct *handle, const char *path, char *list, size_t size)
667 {
668         errno = ENOSYS;
669         return -1;
670 }
671
672 static ssize_t skel_flistxattr(vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
673 {
674         errno = ENOSYS;
675         return -1;
676 }
677
678 static int skel_removexattr(vfs_handle_struct *handle, const char *path, const char *name)
679 {
680         errno = ENOSYS;
681         return -1;
682 }
683
684 static int skel_lremovexattr(vfs_handle_struct *handle, const char *path, const char *name)
685 {
686         errno = ENOSYS;
687         return -1;
688 }
689
690 static int skel_fremovexattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
691 {
692         errno = ENOSYS;
693         return -1;
694         return SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
695 }
696
697 static int skel_setxattr(vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
698 {
699         errno = ENOSYS;
700         return -1;
701 }
702
703 static int skel_lsetxattr(vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
704 {
705         errno = ENOSYS;
706         return -1;
707 }
708
709 static int skel_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
710 {
711         errno = ENOSYS;
712         return -1;
713 }
714
715 static int skel_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
716 {
717         errno = ENOSYS;
718         return -1;
719 }
720
721 static int skel_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
722 {
723         errno = ENOSYS;
724         return -1;
725 }
726
727 static ssize_t skel_aio_return_fn(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
728 {
729         errno = ENOSYS;
730         return -1;
731 }
732
733 static int skel_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
734 {
735         errno = ENOSYS;
736         return -1;
737 }
738
739 static int skel_aio_error_fn(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
740 {
741         errno = ENOSYS;
742         return -1;
743 }
744
745 static int skel_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
746 {
747         errno = ENOSYS;
748         return -1;
749 }
750
751 static int skel_aio_suspend(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_AIOCB * const aiocb[], int n, const struct timespec *ts)
752 {
753         errno = ENOSYS;
754         return -1;
755 }
756
757 static bool skel_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
758 {
759         errno = ENOSYS;
760         return false;
761 }
762
763 static bool skel_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
764 {
765         errno = ENOSYS;
766         return false;
767 }
768
769 static int skel_set_offline(struct vfs_handle_struct *handle, const char *path)
770 {
771         errno = ENOSYS;
772         return -1;
773 }
774
775 /* VFS operations structure */
776
777 struct vfs_fn_pointers skel_transparent_fns = {
778         /* Disk operations */
779
780         .connect_fn = skel_connect,
781         .disconnect = skel_disconnect,
782         .disk_free = skel_disk_free,
783         .get_quota = skel_get_quota,
784         .set_quota = skel_set_quota,
785         .get_shadow_copy_data = skel_get_shadow_copy_data,
786         .statvfs = skel_statvfs,
787         .fs_capabilities = skel_fs_capabilities,
788
789         /* Directory operations */
790
791         .opendir = skel_opendir,
792         .fdopendir = skel_fdopendir,
793         .readdir = skel_readdir,
794         .seekdir = skel_seekdir,
795         .telldir = skel_telldir,
796         .rewind_dir = skel_rewind_dir,
797         .mkdir = skel_mkdir,
798         .rmdir = skel_rmdir,
799         .closedir = skel_closedir,
800         .init_search_op = skel_init_search_op,
801
802         /* File operations */
803
804         .open = skel_open,
805         .create_file = skel_create_file,
806         .close_fn = skel_close_fn,
807         .vfs_read = skel_vfs_read,
808         .pread = skel_pread,
809         .write = skel_write,
810         .pwrite = skel_pwrite,
811         .lseek = skel_lseek,
812         .sendfile = skel_sendfile,
813         .recvfile = skel_recvfile,
814         .rename = skel_rename,
815         .fsync = skel_fsync,
816         .stat = skel_stat,
817         .fstat = skel_fstat,
818         .lstat = skel_lstat,
819         .get_alloc_size = skel_get_alloc_size,
820         .unlink = skel_unlink,
821         .chmod = skel_chmod,
822         .fchmod = skel_fchmod,
823         .chown = skel_chown,
824         .fchown = skel_fchown,
825         .lchown = skel_lchown,
826         .chdir = skel_chdir,
827         .getwd = skel_getwd,
828         .ntimes = skel_ntimes,
829         .ftruncate = skel_ftruncate,
830         .fallocate = skel_fallocate,
831         .lock = skel_lock,
832         .kernel_flock = skel_kernel_flock,
833         .linux_setlease = skel_linux_setlease,
834         .getlock = skel_getlock,
835         .symlink = skel_symlink,
836         .vfs_readlink = skel_vfs_readlink,
837         .link = skel_link,
838         .mknod = skel_mknod,
839         .realpath = skel_realpath,
840         .notify_watch = skel_notify_watch,
841         .chflags = skel_chflags,
842         .file_id_create = skel_file_id_create,
843
844         .streaminfo = skel_streaminfo,
845         .get_real_filename = skel_get_real_filename,
846         .connectpath = skel_connectpath,
847         .brl_lock_windows = skel_brl_lock_windows,
848         .brl_unlock_windows = skel_brl_unlock_windows,
849         .brl_cancel_windows = skel_brl_cancel_windows,
850         .strict_lock = skel_strict_lock,
851         .strict_unlock = skel_strict_unlock,
852         .translate_name = skel_translate_name,
853
854         /* NT ACL operations. */
855
856         .fget_nt_acl = skel_fget_nt_acl,
857         .get_nt_acl = skel_get_nt_acl,
858         .fset_nt_acl = skel_fset_nt_acl,
859
860         /* POSIX ACL operations. */
861
862         .chmod_acl = skel_chmod_acl,
863         .fchmod_acl = skel_fchmod_acl,
864
865         .sys_acl_get_entry = skel_sys_acl_get_entry,
866         .sys_acl_get_tag_type = skel_sys_acl_get_tag_type,
867         .sys_acl_get_permset = skel_sys_acl_get_permset,
868         .sys_acl_get_qualifier = skel_sys_acl_get_qualifier,
869         .sys_acl_get_file = skel_sys_acl_get_file,
870         .sys_acl_get_fd = skel_sys_acl_get_fd,
871         .sys_acl_clear_perms = skel_sys_acl_clear_perms,
872         .sys_acl_add_perm = skel_sys_acl_add_perm,
873         .sys_acl_to_text = skel_sys_acl_to_text,
874         .sys_acl_init = skel_sys_acl_init,
875         .sys_acl_create_entry = skel_sys_acl_create_entry,
876         .sys_acl_set_tag_type = skel_sys_acl_set_tag_type,
877         .sys_acl_set_qualifier = skel_sys_acl_set_qualifier,
878         .sys_acl_set_permset = skel_sys_acl_set_permset,
879         .sys_acl_valid = skel_sys_acl_valid,
880         .sys_acl_set_file = skel_sys_acl_set_file,
881         .sys_acl_set_fd = skel_sys_acl_set_fd,
882         .sys_acl_delete_def_file = skel_sys_acl_delete_def_file,
883         .sys_acl_get_perm = skel_sys_acl_get_perm,
884         .sys_acl_free_text = skel_sys_acl_free_text,
885         .sys_acl_free_acl = skel_sys_acl_free_acl,
886         .sys_acl_free_qualifier = skel_sys_acl_free_qualifier,
887
888         /* EA operations. */
889         .getxattr = skel_getxattr,
890         .lgetxattr = skel_lgetxattr,
891         .fgetxattr = skel_fgetxattr,
892         .listxattr = skel_listxattr,
893         .llistxattr = skel_llistxattr,
894         .flistxattr = skel_flistxattr,
895         .removexattr = skel_removexattr,
896         .lremovexattr = skel_lremovexattr,
897         .fremovexattr = skel_fremovexattr,
898         .setxattr = skel_setxattr,
899         .lsetxattr = skel_lsetxattr,
900         .fsetxattr = skel_fsetxattr,
901
902         /* aio operations */
903         .aio_read = skel_aio_read,
904         .aio_write = skel_aio_write,
905         .aio_return_fn = skel_aio_return_fn,
906         .aio_cancel = skel_aio_cancel,
907         .aio_error_fn = skel_aio_error_fn,
908         .aio_fsync = skel_aio_fsync,
909         .aio_suspend = skel_aio_suspend,
910         .aio_force = skel_aio_force,
911
912         /* offline operations */
913         .is_offline = skel_is_offline,
914         .set_offline = skel_set_offline
915 };
916
917 NTSTATUS vfs_skel_transparent_init(void)
918 {
919         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_transparent", &skel_transparent_fns);
920 }