source: vendor/3.5.6/examples/VFS/skel_opaque.c

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

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