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 }