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 "../source3/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, struct 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 NTSTATUS skel_get_dfs_referrals(struct vfs_handle_struct *handle,
  86                                        struct dfs_GetDFSReferral *r)
  87 {
  88         return NT_STATUS_NOT_IMPLEMENTED;
  89 }
  90
  91 static DIR *skel_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
  92 {
  93         return NULL;
  94 }
  95
  96 static DIR *skel_fdopendir(vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32 attr)
  97 {
  98         return NULL;
  99 }
 100
 101 static struct dirent *skel_readdir(vfs_handle_struct *handle,
 102                                        DIR *dirp,
 103                                        SMB_STRUCT_STAT *sbuf)
 104 {
 105         return NULL;
 106 }
 107
 108 static void skel_seekdir(vfs_handle_struct *handle,  DIR *dirp, long offset)
 109 {
 110         ;
 111 }
 112
 113 static long skel_telldir(vfs_handle_struct *handle,  DIR *dirp)
 114 {
 115         return (long)-1;
 116 }
 117
 118 static void skel_rewind_dir(vfs_handle_struct *handle, DIR *dirp)
 119 {
 120         ;
 121 }
 122
 123 static int skel_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
 124 {
 125         errno = ENOSYS;
 126         return -1;
 127 }
 128
 129 static int skel_rmdir(vfs_handle_struct *handle,  const char *path)
 130 {
 131         errno = ENOSYS;
 132         return -1;
 133 }
 134
 135 static int skel_closedir(vfs_handle_struct *handle,  DIR *dir)
 136 {
 137         errno = ENOSYS;
 138         return -1;
 139 }
 140
 141 static void skel_init_search_op(struct vfs_handle_struct *handle, DIR *dirp)
 142 {
 143         ;
 144 }
 145
 146 static int skel_open(vfs_handle_struct *handle, struct smb_filename *smb_fname,
 147                      files_struct *fsp, int flags, mode_t mode)
 148 {
 149         errno = ENOSYS;
 150         return -1;
 151 }
 152
 153 static NTSTATUS skel_create_file(struct vfs_handle_struct *handle,
 154                                 struct smb_request *req,
 155                                 uint16_t root_dir_fid,
 156                                 struct smb_filename *smb_fname,
 157                                 uint32_t access_mask,
 158                                 uint32_t share_access,
 159                                 uint32_t create_disposition,
 160                                 uint32_t create_options,
 161                                 uint32_t file_attributes,
 162                                 uint32_t oplock_request,
 163                                 uint64_t allocation_size,
 164                                 uint32_t private_flags,
 165                                 struct security_descriptor *sd,
 166                                 struct ea_list *ea_list,
 167                                 files_struct **result,
 168                                 int *pinfo)
 169 {
 170         return NT_STATUS_NOT_IMPLEMENTED;
 171 }
 172
 173 static int skel_close_fn(vfs_handle_struct *handle, files_struct *fsp)
 174 {
 175         errno = ENOSYS;
 176         return -1;
 177 }
 178
 179 static ssize_t skel_vfs_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
 180 {
 181         errno = ENOSYS;
 182         return -1;
 183 }
 184
 185 static ssize_t skel_pread(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n, off_t offset)
 186 {
 187         errno = ENOSYS;
 188         return -1;
 189 }
 190
 191 static ssize_t skel_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 192 {
 193         errno = ENOSYS;
 194         return -1;
 195 }
 196
 197 static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, off_t offset)
 198 {
 199         errno = ENOSYS;
 200         return -1;
 201 }
 202
 203 static off_t skel_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
 204 {
 205         errno = ENOSYS;
 206         return (off_t)-1;
 207 }
 208
 209 static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, off_t offset, size_t n)
 210 {
 211         errno = ENOSYS;
 212         return -1;
 213 }
 214
 215 static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, off_t offset, size_t n)
 216 {
 217         errno = ENOSYS;
 218         return -1;
 219 }
 220
 221 static int skel_rename(vfs_handle_struct *handle,
 222                        const struct smb_filename *smb_fname_src,
 223                        const struct smb_filename *smb_fname_dst)
 224 {
 225         errno = ENOSYS;
 226         return -1;
 227 }
 228
 229 static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp)
 230 {
 231         errno = ENOSYS;
 232         return -1;
 233 }
 234
 235 static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
 236 {
 237         errno = ENOSYS;
 238         return -1;
 239 }
 240
 241 static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 242 {
 243         errno = ENOSYS;
 244         return -1;
 245 }
 246
 247 static int skel_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
 248 {
 249         errno = ENOSYS;
 250         return -1;
 251 }
 252
 253 static uint64_t skel_get_alloc_size(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
 254 {
 255         errno = ENOSYS;
 256         return -1;
 257 }
 258
 259 static int skel_unlink(vfs_handle_struct *handle,
 260                        const struct smb_filename *smb_fname)
 261 {
 262         errno = ENOSYS;
 263         return -1;
 264 }
 265
 266 static int skel_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
 267 {
 268         errno = ENOSYS;
 269         return -1;
 270 }
 271
 272 static int skel_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 273 {
 274         errno = ENOSYS;
 275         return -1;
 276 }
 277
 278 static int skel_chown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
 279 {
 280         errno = ENOSYS;
 281         return -1;
 282 }
 283
 284 static int skel_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 285 {
 286         errno = ENOSYS;
 287         return -1;
 288 }
 289
 290 static int skel_lchown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
 291 {
 292         errno = ENOSYS;
 293         return -1;
 294 }
 295
 296 static int skel_chdir(vfs_handle_struct *handle,  const char *path)
 297 {
 298         errno = ENOSYS;
 299         return -1;
 300 }
 301
 302 static char *skel_getwd(vfs_handle_struct *handle)
 303 {
 304         errno = ENOSYS;
 305         return NULL;
 306 }
 307
 308 static int skel_ntimes(vfs_handle_struct *handle,
 309                        const struct smb_filename *smb_fname,
 310                        struct smb_file_time *ft)
 311 {
 312         errno = ENOSYS;
 313         return -1;
 314 }
 315
 316 static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t offset)
 317 {
 318         errno = ENOSYS;
 319         return -1;
 320 }
 321
 322 static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
 323                         enum vfs_fallocate_mode mode,
 324                         off_t offset, off_t len)
 325 {
 326         errno = ENOSYS;
 327         return -1;
 328 }
 329
 330 static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
 331 {
 332         errno = ENOSYS;
 333         return false;
 334 }
 335
 336 static int skel_kernel_flock(struct vfs_handle_struct *handle, struct files_struct *fsp, uint32 share_mode, uint32 access_mask)
 337 {
 338         errno = ENOSYS;
 339         return -1;
 340 }
 341
 342 static int skel_linux_setlease(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype)
 343 {
 344         errno = ENOSYS;
 345         return -1;
 346 }
 347
 348 static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
 349 {
 350         errno = ENOSYS;
 351         return false;
 352 }
 353
 354 static int skel_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 355 {
 356         errno = ENOSYS;
 357         return -1;
 358 }
 359
 360 static int skel_vfs_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
 361 {
 362         errno = ENOSYS;
 363         return -1;
 364 }
 365
 366 static int skel_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 367 {
 368         errno = ENOSYS;
 369         return -1;
 370 }
 371
 372 static int skel_mknod(vfs_handle_struct *handle,  const char *path, mode_t mode, SMB_DEV_T dev)
 373 {
 374         errno = ENOSYS;
 375         return -1;
 376 }
 377
 378 static char *skel_realpath(vfs_handle_struct *handle,  const char *path)
 379 {
 380         errno = ENOSYS;
 381         return NULL;
 382 }
 383
 384 static NTSTATUS skel_notify_watch(struct vfs_handle_struct *handle,
 385             struct sys_notify_context *ctx,
 386             const char *path,
 387             uint32_t *filter,
 388             uint32_t *subdir_filter,
 389             void (*callback)(struct sys_notify_context *ctx, void *private_data, struct notify_event *ev),
 390             void *private_data, void *handle_p)
 391 {
 392         return NT_STATUS_NOT_IMPLEMENTED;
 393 }
 394
 395 static int skel_chflags(vfs_handle_struct *handle,  const char *path, uint flags)
 396 {
 397         errno = ENOSYS;
 398         return -1;
 399 }
 400
 401 static struct file_id skel_file_id_create(vfs_handle_struct *handle,
 402                                           const SMB_STRUCT_STAT *sbuf)
 403 {
 404         struct file_id id;
 405         ZERO_STRUCT(id);
 406         errno = ENOSYS;
 407         return id;
 408 }
 409
 410 static NTSTATUS skel_streaminfo(struct vfs_handle_struct *handle,
 411                                 struct files_struct *fsp,
 412                                 const char *fname,
 413                                 TALLOC_CTX *mem_ctx,
 414                                 unsigned int *num_streams,
 415                                 struct stream_struct **streams)
 416 {
 417         return NT_STATUS_NOT_IMPLEMENTED;
 418 }
 419
 420 static int skel_get_real_filename(struct vfs_handle_struct *handle,
 421                                 const char *path,
 422                                 const char *name,
 423                                 TALLOC_CTX *mem_ctx,
 424                                 char **found_name)
 425 {
 426         errno = ENOSYS;
 427         return -1;
 428 }
 429
 430 static const char *skel_connectpath(struct vfs_handle_struct *handle,
 431                                 const char *filename)
 432 {
 433         errno = ENOSYS;
 434         return NULL;
 435 }
 436
 437 static NTSTATUS skel_brl_lock_windows(struct vfs_handle_struct *handle,
 438                                 struct byte_range_lock *br_lck,
 439                                 struct lock_struct *plock,
 440                                 bool blocking_lock,
 441                                 struct blocking_lock_record *blr)
 442 {
 443         return NT_STATUS_NOT_IMPLEMENTED;
 444 }
 445
 446 static bool skel_brl_unlock_windows(struct vfs_handle_struct *handle,
 447                                 struct messaging_context *msg_ctx,
 448                                 struct byte_range_lock *br_lck,
 449                                 const struct lock_struct *plock)
 450 {
 451         errno = ENOSYS;
 452         return false;
 453 }
 454
 455 static bool skel_brl_cancel_windows(struct vfs_handle_struct *handle,
 456                                 struct byte_range_lock *br_lck,
 457                                 struct lock_struct *plock,
 458                                 struct blocking_lock_record *blr)
 459 {
 460         errno = ENOSYS;
 461         return false;
 462 }
 463
 464 static bool skel_strict_lock(struct vfs_handle_struct *handle,
 465                                 struct files_struct *fsp,
 466                                 struct lock_struct *plock)
 467 {
 468         errno = ENOSYS;
 469         return false;
 470 }
 471
 472 static void skel_strict_unlock(struct vfs_handle_struct *handle,
 473                                 struct files_struct *fsp,
 474                                 struct lock_struct *plock)
 475 {
 476         ;
 477 }
 478
 479 static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
 480                                 const char *mapped_name,
 481                                 enum vfs_translate_direction direction,
 482                                 TALLOC_CTX *mem_ctx,
 483                                 char **pmapped_name)
 484 {
 485         return NT_STATUS_NOT_IMPLEMENTED;
 486 }
 487
 488 static NTSTATUS skel_fsctl(struct vfs_handle_struct *handle,
 489                         struct files_struct *fsp,
 490                         TALLOC_CTX *ctx,
 491                         uint32_t function,
 492                         uint16_t req_flags,  /* Needed for UNICODE ... */
 493                         const uint8_t *_in_data,
 494                         uint32_t in_len,
 495                         uint8_t **_out_data,
 496                         uint32_t max_out_len,
 497                         uint32_t *out_len)
 498 {
 499         return NT_STATUS_NOT_IMPLEMENTED;
 500 }
 501
 502 static NTSTATUS skel_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 503         uint32 security_info, struct security_descriptor **ppdesc)
 504 {
 505         return NT_STATUS_NOT_IMPLEMENTED;
 506 }
 507
 508 static NTSTATUS skel_get_nt_acl(vfs_handle_struct *handle,
 509         const char *name, uint32 security_info, struct security_descriptor **ppdesc)
 510 {
 511         return NT_STATUS_NOT_IMPLEMENTED;
 512 }
 513
 514 static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 515         uint32 security_info_sent, const struct security_descriptor *psd)
 516 {
 517         return NT_STATUS_NOT_IMPLEMENTED;
 518 }
 519
 520 static int skel_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
 521 {
 522         errno = ENOSYS;
 523         return -1;
 524 }
 525
 526 static int skel_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 527 {
 528         errno = ENOSYS;
 529         return -1;
 530 }
 531
 532 static int skel_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
 533 {
 534         errno = ENOSYS;
 535         return -1;
 536 }
 537
 538 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)
 539 {
 540         errno = ENOSYS;
 541         return -1;
 542 }
 543
 544 static int skel_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
 545 {
 546         errno = ENOSYS;
 547         return -1;
 548 }
 549
 550 static void *skel_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
 551 {
 552         errno = ENOSYS;
 553         return NULL;
 554 }
 555
 556 static SMB_ACL_T skel_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
 557 {
 558         errno = ENOSYS;
 559         return (SMB_ACL_T)NULL;
 560 }
 561
 562 static SMB_ACL_T skel_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
 563 {
 564         errno = ENOSYS;
 565         return (SMB_ACL_T)NULL;
 566 }
 567
 568 static int skel_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
 569 {
 570         errno = ENOSYS;
 571         return -1;
 572 }
 573
 574 static int skel_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 575 {
 576         errno = ENOSYS;
 577         return -1;
 578 }
 579
 580 static char *skel_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
 581 {
 582         errno = ENOSYS;
 583         return NULL;
 584 }
 585
 586 static SMB_ACL_T skel_sys_acl_init(vfs_handle_struct *handle,  int count)
 587 {
 588         errno = ENOSYS;
 589         return (SMB_ACL_T)NULL;
 590 }
 591
 592 static int skel_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
 593 {
 594         errno = ENOSYS;
 595         return -1;
 596 }
 597
 598 static int skel_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
 599 {
 600         errno = ENOSYS;
 601         return -1;
 602 }
 603
 604 static int skel_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
 605 {
 606         errno = ENOSYS;
 607         return -1;
 608 }
 609
 610 static int skel_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
 611 {
 612         errno = ENOSYS;
 613         return -1;
 614 }
 615
 616 static int skel_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
 617 {
 618         errno = ENOSYS;
 619         return -1;
 620 }
 621
 622 static int skel_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 623 {
 624         errno = ENOSYS;
 625         return -1;
 626 }
 627
 628 static int skel_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
 629 {
 630         errno = ENOSYS;
 631         return -1;
 632 }
 633
 634 static int skel_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
 635 {
 636         errno = ENOSYS;
 637         return -1;
 638 }
 639
 640 static int skel_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
 641 {
 642         errno = ENOSYS;
 643         return -1;
 644 }
 645
 646 static int skel_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
 647 {
 648         errno = ENOSYS;
 649         return -1;
 650 }
 651
 652 static int skel_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
 653 {
 654         errno = ENOSYS;
 655         return -1;
 656 }
 657
 658 static int skel_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
 659 {
 660         errno = ENOSYS;
 661         return -1;
 662 }
 663
 664 static ssize_t skel_getxattr(vfs_handle_struct *handle, const char *path, const char *name, void *value, size_t size)
 665 {
 666         errno = ENOSYS;
 667         return -1;
 668 }
 669
 670 static ssize_t skel_fgetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
 671 {
 672         errno = ENOSYS;
 673         return -1;
 674 }
 675
 676 static ssize_t skel_listxattr(vfs_handle_struct *handle, const char *path, char *list, size_t size)
 677 {
 678         errno = ENOSYS;
 679         return -1;
 680 }
 681
 682 static ssize_t skel_flistxattr(vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
 683 {
 684         errno = ENOSYS;
 685         return -1;
 686 }
 687
 688 static int skel_removexattr(vfs_handle_struct *handle, const char *path, const char *name)
 689 {
 690         errno = ENOSYS;
 691         return -1;
 692 }
 693
 694 static int skel_fremovexattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
 695 {
 696         errno = ENOSYS;
 697         return -1;
 698         return SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
 699 }
 700
 701 static int skel_setxattr(vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
 702 {
 703         errno = ENOSYS;
 704         return -1;
 705 }
 706
 707 static int skel_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
 708 {
 709         errno = ENOSYS;
 710         return -1;
 711 }
 712
 713 static int skel_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
 714 {
 715         errno = ENOSYS;
 716         return -1;
 717 }
 718
 719 static int skel_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
 720 {
 721         errno = ENOSYS;
 722         return -1;
 723 }
 724
 725 static ssize_t skel_aio_return_fn(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
 726 {
 727         errno = ENOSYS;
 728         return -1;
 729 }
 730
 731 static int skel_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
 732 {
 733         errno = ENOSYS;
 734         return -1;
 735 }
 736
 737 static int skel_aio_error_fn(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
 738 {
 739         errno = ENOSYS;
 740         return -1;
 741 }
 742
 743 static int skel_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
 744 {
 745         errno = ENOSYS;
 746         return -1;
 747 }
 748
 749 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)
 750 {
 751         errno = ENOSYS;
 752         return -1;
 753 }
 754
 755 static bool skel_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
 756 {
 757         errno = ENOSYS;
 758         return false;
 759 }
 760
 761 static bool skel_is_offline(struct vfs_handle_struct *handle, const struct smb_filename *fname, SMB_STRUCT_STAT *sbuf)
 762 {
 763         errno = ENOSYS;
 764         return false;
 765 }
 766
 767 static int skel_set_offline(struct vfs_handle_struct *handle, const struct smb_filename *fname)
 768 {
 769         errno = ENOSYS;
 770         return -1;
 771 }
 772
 773 /* VFS operations structure */
 774
 775 struct vfs_fn_pointers skel_opaque_fns = {
 776         /* Disk operations */
 777
 778         .connect_fn = skel_connect,
 779         .disconnect_fn = skel_disconnect,
 780         .disk_free_fn = skel_disk_free,
 781         .get_quota_fn = skel_get_quota,
 782         .set_quota_fn = skel_set_quota,
 783         .get_shadow_copy_data_fn = skel_get_shadow_copy_data,
 784         .statvfs_fn = skel_statvfs,
 785         .fs_capabilities_fn = skel_fs_capabilities,
 786         .get_dfs_referrals_fn = skel_get_dfs_referrals,
 787
 788         /* Directory operations */
 789
 790         .opendir_fn = skel_opendir,
 791         .fdopendir_fn = skel_fdopendir,
 792         .readdir_fn = skel_readdir,
 793         .seekdir_fn = skel_seekdir,
 794         .telldir_fn = skel_telldir,
 795         .rewind_dir_fn = skel_rewind_dir,
 796         .mkdir_fn = skel_mkdir,
 797         .rmdir_fn = skel_rmdir,
 798         .closedir_fn = skel_closedir,
 799         .init_search_op_fn = skel_init_search_op,
 800
 801         /* File operations */
 802
 803         .open_fn = skel_open,
 804         .create_file_fn = skel_create_file,
 805         .close_fn = skel_close_fn,
 806         .read_fn = skel_vfs_read,
 807         .pread_fn = skel_pread,
 808         .write_fn = skel_write,
 809         .pwrite_fn = skel_pwrite,
 810         .lseek_fn = skel_lseek,
 811         .sendfile_fn = skel_sendfile,
 812         .recvfile_fn = skel_recvfile,
 813         .rename_fn = skel_rename,
 814         .fsync_fn = skel_fsync,
 815         .stat_fn = skel_stat,
 816         .fstat_fn = skel_fstat,
 817         .lstat_fn = skel_lstat,
 818         .get_alloc_size_fn = skel_get_alloc_size,
 819         .unlink_fn = skel_unlink,
 820         .chmod_fn = skel_chmod,
 821         .fchmod_fn = skel_fchmod,
 822         .chown_fn = skel_chown,
 823         .fchown_fn = skel_fchown,
 824         .lchown_fn = skel_lchown,
 825         .chdir_fn = skel_chdir,
 826         .getwd_fn = skel_getwd,
 827         .ntimes_fn = skel_ntimes,
 828         .ftruncate_fn = skel_ftruncate,
 829         .fallocate_fn = skel_fallocate,
 830         .lock_fn = skel_lock,
 831         .kernel_flock_fn = skel_kernel_flock,
 832         .linux_setlease_fn = skel_linux_setlease,
 833         .getlock_fn = skel_getlock,
 834         .symlink_fn = skel_symlink,
 835         .readlink_fn = skel_vfs_readlink,
 836         .link_fn = skel_link,
 837         .mknod_fn = skel_mknod,
 838         .realpath_fn = skel_realpath,
 839         .notify_watch_fn = skel_notify_watch,
 840         .chflags_fn = skel_chflags,
 841         .file_id_create_fn = skel_file_id_create,
 842
 843         .streaminfo_fn = skel_streaminfo,
 844         .get_real_filename_fn = skel_get_real_filename,
 845         .connectpath_fn = skel_connectpath,
 846         .brl_lock_windows_fn = skel_brl_lock_windows,
 847         .brl_unlock_windows_fn = skel_brl_unlock_windows,
 848         .brl_cancel_windows_fn = skel_brl_cancel_windows,
 849         .strict_lock_fn = skel_strict_lock,
 850         .strict_unlock_fn = skel_strict_unlock,
 851         .translate_name_fn = skel_translate_name,
 852         .fsctl_fn = skel_fsctl,
 853
 854         /* NT ACL operations. */
 855
 856         .fget_nt_acl_fn = skel_fget_nt_acl,
 857         .get_nt_acl_fn = skel_get_nt_acl,
 858         .fset_nt_acl_fn = skel_fset_nt_acl,
 859
 860         /* POSIX ACL operations. */
 861
 862         .chmod_acl_fn = skel_chmod_acl,
 863         .fchmod_acl_fn = skel_fchmod_acl,
 864
 865         .sys_acl_get_entry_fn = skel_sys_acl_get_entry,
 866         .sys_acl_get_tag_type_fn = skel_sys_acl_get_tag_type,
 867         .sys_acl_get_permset_fn = skel_sys_acl_get_permset,
 868         .sys_acl_get_qualifier_fn = skel_sys_acl_get_qualifier,
 869         .sys_acl_get_file_fn = skel_sys_acl_get_file,
 870         .sys_acl_get_fd_fn = skel_sys_acl_get_fd,
 871         .sys_acl_clear_perms_fn = skel_sys_acl_clear_perms,
 872         .sys_acl_add_perm_fn = skel_sys_acl_add_perm,
 873         .sys_acl_to_text_fn = skel_sys_acl_to_text,
 874         .sys_acl_init_fn = skel_sys_acl_init,
 875         .sys_acl_create_entry_fn = skel_sys_acl_create_entry,
 876         .sys_acl_set_tag_type_fn = skel_sys_acl_set_tag_type,
 877         .sys_acl_set_qualifier_fn = skel_sys_acl_set_qualifier,
 878         .sys_acl_set_permset_fn = skel_sys_acl_set_permset,
 879         .sys_acl_valid_fn = skel_sys_acl_valid,
 880         .sys_acl_set_file_fn = skel_sys_acl_set_file,
 881         .sys_acl_set_fd_fn = skel_sys_acl_set_fd,
 882         .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file,
 883         .sys_acl_get_perm_fn = skel_sys_acl_get_perm,
 884         .sys_acl_free_text_fn = skel_sys_acl_free_text,
 885         .sys_acl_free_acl_fn = skel_sys_acl_free_acl,
 886         .sys_acl_free_qualifier_fn = skel_sys_acl_free_qualifier,
 887
 888         /* EA operations. */
 889         .getxattr_fn = skel_getxattr,
 890         .fgetxattr_fn = skel_fgetxattr,
 891         .listxattr_fn = skel_listxattr,
 892         .flistxattr_fn = skel_flistxattr,
 893         .removexattr_fn = skel_removexattr,
 894         .fremovexattr_fn = skel_fremovexattr,
 895         .setxattr_fn = skel_setxattr,
 896         .fsetxattr_fn = skel_fsetxattr,
 897
 898         /* aio operations */
 899         .aio_read_fn = skel_aio_read,
 900         .aio_write_fn = skel_aio_write,
 901         .aio_return_fn = skel_aio_return_fn,
 902         .aio_cancel_fn = skel_aio_cancel,
 903         .aio_error_fn = skel_aio_error_fn,
 904         .aio_fsync_fn = skel_aio_fsync,
 905         .aio_suspend_fn = skel_aio_suspend,
 906         .aio_force_fn = skel_aio_force,
 907
 908         /* offline operations */
 909         .is_offline_fn = skel_is_offline,
 910         .set_offline_fn = skel_set_offline
 911 };
 912
 913 NTSTATUS vfs_skel_opaque_init(void)
 914 {
 915         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_opaque", &skel_opaque_fns);
 916 }