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 struct tevent_req *skel_pread_send(struct vfs_handle_struct *handle,
 192                                           TALLOC_CTX *mem_ctx,
 193                                           struct tevent_context *ev,
 194                                           struct files_struct *fsp,
 195                                           void *data, size_t n, off_t offset)
 196 {
 197         return NULL;
 198 }
 199
 200 static ssize_t skel_pread_recv(struct tevent_req *req, int *err)
 201 {
 202         *err = ENOSYS;
 203         return -1;
 204 }
 205
 206 static ssize_t skel_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 207 {
 208         errno = ENOSYS;
 209         return -1;
 210 }
 211
 212 static ssize_t skel_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n, off_t offset)
 213 {
 214         errno = ENOSYS;
 215         return -1;
 216 }
 217
 218 static struct tevent_req *skel_pwrite_send(struct vfs_handle_struct *handle,
 219                                            TALLOC_CTX *mem_ctx,
 220                                            struct tevent_context *ev,
 221                                            struct files_struct *fsp,
 222                                            const void *data,
 223                                            size_t n, off_t offset)
 224 {
 225         return NULL;
 226 }
 227
 228 static ssize_t skel_pwrite_recv(struct tevent_req *req, int *err)
 229 {
 230         *err = ENOSYS;
 231         return -1;
 232 }
 233
 234 static off_t skel_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
 235 {
 236         errno = ENOSYS;
 237         return (off_t)-1;
 238 }
 239
 240 static ssize_t skel_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr, off_t offset, size_t n)
 241 {
 242         errno = ENOSYS;
 243         return -1;
 244 }
 245
 246 static ssize_t skel_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, off_t offset, size_t n)
 247 {
 248         errno = ENOSYS;
 249         return -1;
 250 }
 251
 252 static int skel_rename(vfs_handle_struct *handle,
 253                        const struct smb_filename *smb_fname_src,
 254                        const struct smb_filename *smb_fname_dst)
 255 {
 256         errno = ENOSYS;
 257         return -1;
 258 }
 259
 260 static int skel_fsync(vfs_handle_struct *handle, files_struct *fsp)
 261 {
 262         errno = ENOSYS;
 263         return -1;
 264 }
 265
 266 static struct tevent_req *skel_fsync_send(struct vfs_handle_struct *handle,
 267                                           TALLOC_CTX *mem_ctx,
 268                                           struct tevent_context *ev,
 269                                           struct files_struct *fsp)
 270 {
 271         return NULL;
 272 }
 273
 274 static int skel_fsync_recv(struct tevent_req *req, int *err)
 275 {
 276         *err = ENOSYS;
 277         return -1;
 278 }
 279
 280 static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
 281 {
 282         errno = ENOSYS;
 283         return -1;
 284 }
 285
 286 static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 287 {
 288         errno = ENOSYS;
 289         return -1;
 290 }
 291
 292 static int skel_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
 293 {
 294         errno = ENOSYS;
 295         return -1;
 296 }
 297
 298 static uint64_t skel_get_alloc_size(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf)
 299 {
 300         errno = ENOSYS;
 301         return -1;
 302 }
 303
 304 static int skel_unlink(vfs_handle_struct *handle,
 305                        const struct smb_filename *smb_fname)
 306 {
 307         errno = ENOSYS;
 308         return -1;
 309 }
 310
 311 static int skel_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
 312 {
 313         errno = ENOSYS;
 314         return -1;
 315 }
 316
 317 static int skel_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 318 {
 319         errno = ENOSYS;
 320         return -1;
 321 }
 322
 323 static int skel_chown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
 324 {
 325         errno = ENOSYS;
 326         return -1;
 327 }
 328
 329 static int skel_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 330 {
 331         errno = ENOSYS;
 332         return -1;
 333 }
 334
 335 static int skel_lchown(vfs_handle_struct *handle,  const char *path, uid_t uid, gid_t gid)
 336 {
 337         errno = ENOSYS;
 338         return -1;
 339 }
 340
 341 static int skel_chdir(vfs_handle_struct *handle,  const char *path)
 342 {
 343         errno = ENOSYS;
 344         return -1;
 345 }
 346
 347 static char *skel_getwd(vfs_handle_struct *handle)
 348 {
 349         errno = ENOSYS;
 350         return NULL;
 351 }
 352
 353 static int skel_ntimes(vfs_handle_struct *handle,
 354                        const struct smb_filename *smb_fname,
 355                        struct smb_file_time *ft)
 356 {
 357         errno = ENOSYS;
 358         return -1;
 359 }
 360
 361 static int skel_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t offset)
 362 {
 363         errno = ENOSYS;
 364         return -1;
 365 }
 366
 367 static int skel_fallocate(vfs_handle_struct *handle, files_struct *fsp,
 368                         enum vfs_fallocate_mode mode,
 369                         off_t offset, off_t len)
 370 {
 371         errno = ENOSYS;
 372         return -1;
 373 }
 374
 375 static bool skel_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
 376 {
 377         errno = ENOSYS;
 378         return false;
 379 }
 380
 381 static int skel_kernel_flock(struct vfs_handle_struct *handle, struct files_struct *fsp, uint32 share_mode, uint32 access_mask)
 382 {
 383         errno = ENOSYS;
 384         return -1;
 385 }
 386
 387 static int skel_linux_setlease(struct vfs_handle_struct *handle, struct files_struct *fsp, int leasetype)
 388 {
 389         errno = ENOSYS;
 390         return -1;
 391 }
 392
 393 static bool skel_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
 394 {
 395         errno = ENOSYS;
 396         return false;
 397 }
 398
 399 static int skel_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 400 {
 401         errno = ENOSYS;
 402         return -1;
 403 }
 404
 405 static int skel_vfs_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
 406 {
 407         errno = ENOSYS;
 408         return -1;
 409 }
 410
 411 static int skel_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 412 {
 413         errno = ENOSYS;
 414         return -1;
 415 }
 416
 417 static int skel_mknod(vfs_handle_struct *handle,  const char *path, mode_t mode, SMB_DEV_T dev)
 418 {
 419         errno = ENOSYS;
 420         return -1;
 421 }
 422
 423 static char *skel_realpath(vfs_handle_struct *handle,  const char *path)
 424 {
 425         errno = ENOSYS;
 426         return NULL;
 427 }
 428
 429 static NTSTATUS skel_notify_watch(struct vfs_handle_struct *handle,
 430             struct sys_notify_context *ctx,
 431             const char *path,
 432             uint32_t *filter,
 433             uint32_t *subdir_filter,
 434             void (*callback)(struct sys_notify_context *ctx, void *private_data, struct notify_event *ev),
 435             void *private_data, void *handle_p)
 436 {
 437         return NT_STATUS_NOT_IMPLEMENTED;
 438 }
 439
 440 static int skel_chflags(vfs_handle_struct *handle,  const char *path, uint flags)
 441 {
 442         errno = ENOSYS;
 443         return -1;
 444 }
 445
 446 static struct file_id skel_file_id_create(vfs_handle_struct *handle,
 447                                           const SMB_STRUCT_STAT *sbuf)
 448 {
 449         struct file_id id;
 450         ZERO_STRUCT(id);
 451         errno = ENOSYS;
 452         return id;
 453 }
 454
 455 static NTSTATUS skel_streaminfo(struct vfs_handle_struct *handle,
 456                                 struct files_struct *fsp,
 457                                 const char *fname,
 458                                 TALLOC_CTX *mem_ctx,
 459                                 unsigned int *num_streams,
 460                                 struct stream_struct **streams)
 461 {
 462         return NT_STATUS_NOT_IMPLEMENTED;
 463 }
 464
 465 static int skel_get_real_filename(struct vfs_handle_struct *handle,
 466                                 const char *path,
 467                                 const char *name,
 468                                 TALLOC_CTX *mem_ctx,
 469                                 char **found_name)
 470 {
 471         errno = ENOSYS;
 472         return -1;
 473 }
 474
 475 static const char *skel_connectpath(struct vfs_handle_struct *handle,
 476                                 const char *filename)
 477 {
 478         errno = ENOSYS;
 479         return NULL;
 480 }
 481
 482 static NTSTATUS skel_brl_lock_windows(struct vfs_handle_struct *handle,
 483                                 struct byte_range_lock *br_lck,
 484                                 struct lock_struct *plock,
 485                                 bool blocking_lock,
 486                                 struct blocking_lock_record *blr)
 487 {
 488         return NT_STATUS_NOT_IMPLEMENTED;
 489 }
 490
 491 static bool skel_brl_unlock_windows(struct vfs_handle_struct *handle,
 492                                 struct messaging_context *msg_ctx,
 493                                 struct byte_range_lock *br_lck,
 494                                 const struct lock_struct *plock)
 495 {
 496         errno = ENOSYS;
 497         return false;
 498 }
 499
 500 static bool skel_brl_cancel_windows(struct vfs_handle_struct *handle,
 501                                 struct byte_range_lock *br_lck,
 502                                 struct lock_struct *plock,
 503                                 struct blocking_lock_record *blr)
 504 {
 505         errno = ENOSYS;
 506         return false;
 507 }
 508
 509 static bool skel_strict_lock(struct vfs_handle_struct *handle,
 510                                 struct files_struct *fsp,
 511                                 struct lock_struct *plock)
 512 {
 513         errno = ENOSYS;
 514         return false;
 515 }
 516
 517 static void skel_strict_unlock(struct vfs_handle_struct *handle,
 518                                 struct files_struct *fsp,
 519                                 struct lock_struct *plock)
 520 {
 521         ;
 522 }
 523
 524 static NTSTATUS skel_translate_name(struct vfs_handle_struct *handle,
 525                                 const char *mapped_name,
 526                                 enum vfs_translate_direction direction,
 527                                 TALLOC_CTX *mem_ctx,
 528                                 char **pmapped_name)
 529 {
 530         return NT_STATUS_NOT_IMPLEMENTED;
 531 }
 532
 533 static NTSTATUS skel_fsctl(struct vfs_handle_struct *handle,
 534                         struct files_struct *fsp,
 535                         TALLOC_CTX *ctx,
 536                         uint32_t function,
 537                         uint16_t req_flags,  /* Needed for UNICODE ... */
 538                         const uint8_t *_in_data,
 539                         uint32_t in_len,
 540                         uint8_t **_out_data,
 541                         uint32_t max_out_len,
 542                         uint32_t *out_len)
 543 {
 544         return NT_STATUS_NOT_IMPLEMENTED;
 545 }
 546
 547 static NTSTATUS skel_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 548                                  uint32 security_info,
 549                                  TALLOC_CTX *mem_ctx,
 550                                  struct security_descriptor **ppdesc)
 551 {
 552         return NT_STATUS_NOT_IMPLEMENTED;
 553 }
 554
 555 static NTSTATUS skel_get_nt_acl(vfs_handle_struct *handle,
 556                                 const char *name, uint32 security_info,
 557                                 TALLOC_CTX *mem_ctx,
 558                                 struct security_descriptor **ppdesc)
 559 {
 560         return NT_STATUS_NOT_IMPLEMENTED;
 561 }
 562
 563 static NTSTATUS skel_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 564         uint32 security_info_sent, const struct security_descriptor *psd)
 565 {
 566         return NT_STATUS_NOT_IMPLEMENTED;
 567 }
 568
 569 static int skel_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
 570 {
 571         errno = ENOSYS;
 572         return -1;
 573 }
 574
 575 static int skel_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 576 {
 577         errno = ENOSYS;
 578         return -1;
 579 }
 580
 581 static SMB_ACL_T skel_sys_acl_get_file(vfs_handle_struct *handle,
 582                                        const char *path_p,
 583                                        SMB_ACL_TYPE_T type,
 584                                        TALLOC_CTX *mem_ctx)
 585 {
 586         errno = ENOSYS;
 587         return (SMB_ACL_T)NULL;
 588 }
 589
 590 static SMB_ACL_T skel_sys_acl_get_fd(vfs_handle_struct *handle,
 591                                      files_struct *fsp,
 592                                      TALLOC_CTX *mem_ctx)
 593 {
 594         errno = ENOSYS;
 595         return (SMB_ACL_T)NULL;
 596 }
 597
 598 static int skel_sys_acl_blob_get_file(vfs_handle_struct *handle,  const char *path_p, TALLOC_CTX *mem_ctx, char **blob_description, DATA_BLOB *blob)
 599 {
 600         errno = ENOSYS;
 601         return -1;
 602 }
 603
 604 static int skel_sys_acl_blob_get_fd(vfs_handle_struct *handle, files_struct *fsp, TALLOC_CTX *mem_ctx, char **blob_description, DATA_BLOB *blob)
 605 {
 606         errno = ENOSYS;
 607         return -1;
 608 }
 609
 610 static int skel_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
 611 {
 612         errno = ENOSYS;
 613         return -1;
 614 }
 615
 616 static int skel_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
 617 {
 618         errno = ENOSYS;
 619         return -1;
 620 }
 621
 622 static int skel_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
 623 {
 624         errno = ENOSYS;
 625         return -1;
 626 }
 627
 628 static ssize_t skel_getxattr(vfs_handle_struct *handle, const char *path, const char *name, void *value, size_t size)
 629 {
 630         errno = ENOSYS;
 631         return -1;
 632 }
 633
 634 static ssize_t skel_fgetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
 635 {
 636         errno = ENOSYS;
 637         return -1;
 638 }
 639
 640 static ssize_t skel_listxattr(vfs_handle_struct *handle, const char *path, char *list, size_t size)
 641 {
 642         errno = ENOSYS;
 643         return -1;
 644 }
 645
 646 static ssize_t skel_flistxattr(vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
 647 {
 648         errno = ENOSYS;
 649         return -1;
 650 }
 651
 652 static int skel_removexattr(vfs_handle_struct *handle, const char *path, const char *name)
 653 {
 654         errno = ENOSYS;
 655         return -1;
 656 }
 657
 658 static int skel_fremovexattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
 659 {
 660         errno = ENOSYS;
 661         return -1;
 662         return SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
 663 }
 664
 665 static int skel_setxattr(vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
 666 {
 667         errno = ENOSYS;
 668         return -1;
 669 }
 670
 671 static int skel_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
 672 {
 673         errno = ENOSYS;
 674         return -1;
 675 }
 676
 677 static bool skel_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
 678 {
 679         errno = ENOSYS;
 680         return false;
 681 }
 682
 683 static bool skel_is_offline(struct vfs_handle_struct *handle, const struct smb_filename *fname, SMB_STRUCT_STAT *sbuf)
 684 {
 685         errno = ENOSYS;
 686         return false;
 687 }
 688
 689 static int skel_set_offline(struct vfs_handle_struct *handle, const struct smb_filename *fname)
 690 {
 691         errno = ENOSYS;
 692         return -1;
 693 }
 694
 695 /* VFS operations structure */
 696
 697 struct vfs_fn_pointers skel_opaque_fns = {
 698         /* Disk operations */
 699
 700         .connect_fn = skel_connect,
 701         .disconnect_fn = skel_disconnect,
 702         .disk_free_fn = skel_disk_free,
 703         .get_quota_fn = skel_get_quota,
 704         .set_quota_fn = skel_set_quota,
 705         .get_shadow_copy_data_fn = skel_get_shadow_copy_data,
 706         .statvfs_fn = skel_statvfs,
 707         .fs_capabilities_fn = skel_fs_capabilities,
 708         .get_dfs_referrals_fn = skel_get_dfs_referrals,
 709
 710         /* Directory operations */
 711
 712         .opendir_fn = skel_opendir,
 713         .fdopendir_fn = skel_fdopendir,
 714         .readdir_fn = skel_readdir,
 715         .seekdir_fn = skel_seekdir,
 716         .telldir_fn = skel_telldir,
 717         .rewind_dir_fn = skel_rewind_dir,
 718         .mkdir_fn = skel_mkdir,
 719         .rmdir_fn = skel_rmdir,
 720         .closedir_fn = skel_closedir,
 721         .init_search_op_fn = skel_init_search_op,
 722
 723         /* File operations */
 724
 725         .open_fn = skel_open,
 726         .create_file_fn = skel_create_file,
 727         .close_fn = skel_close_fn,
 728         .read_fn = skel_vfs_read,
 729         .pread_fn = skel_pread,
 730         .pread_send_fn = skel_pread_send,
 731         .pread_recv_fn = skel_pread_recv,
 732         .write_fn = skel_write,
 733         .pwrite_fn = skel_pwrite,
 734         .pwrite_send_fn = skel_pwrite_send,
 735         .pwrite_recv_fn = skel_pwrite_recv,
 736         .lseek_fn = skel_lseek,
 737         .sendfile_fn = skel_sendfile,
 738         .recvfile_fn = skel_recvfile,
 739         .rename_fn = skel_rename,
 740         .fsync_fn = skel_fsync,
 741         .fsync_send_fn = skel_fsync_send,
 742         .fsync_recv_fn = skel_fsync_recv,
 743         .stat_fn = skel_stat,
 744         .fstat_fn = skel_fstat,
 745         .lstat_fn = skel_lstat,
 746         .get_alloc_size_fn = skel_get_alloc_size,
 747         .unlink_fn = skel_unlink,
 748         .chmod_fn = skel_chmod,
 749         .fchmod_fn = skel_fchmod,
 750         .chown_fn = skel_chown,
 751         .fchown_fn = skel_fchown,
 752         .lchown_fn = skel_lchown,
 753         .chdir_fn = skel_chdir,
 754         .getwd_fn = skel_getwd,
 755         .ntimes_fn = skel_ntimes,
 756         .ftruncate_fn = skel_ftruncate,
 757         .fallocate_fn = skel_fallocate,
 758         .lock_fn = skel_lock,
 759         .kernel_flock_fn = skel_kernel_flock,
 760         .linux_setlease_fn = skel_linux_setlease,
 761         .getlock_fn = skel_getlock,
 762         .symlink_fn = skel_symlink,
 763         .readlink_fn = skel_vfs_readlink,
 764         .link_fn = skel_link,
 765         .mknod_fn = skel_mknod,
 766         .realpath_fn = skel_realpath,
 767         .notify_watch_fn = skel_notify_watch,
 768         .chflags_fn = skel_chflags,
 769         .file_id_create_fn = skel_file_id_create,
 770
 771         .streaminfo_fn = skel_streaminfo,
 772         .get_real_filename_fn = skel_get_real_filename,
 773         .connectpath_fn = skel_connectpath,
 774         .brl_lock_windows_fn = skel_brl_lock_windows,
 775         .brl_unlock_windows_fn = skel_brl_unlock_windows,
 776         .brl_cancel_windows_fn = skel_brl_cancel_windows,
 777         .strict_lock_fn = skel_strict_lock,
 778         .strict_unlock_fn = skel_strict_unlock,
 779         .translate_name_fn = skel_translate_name,
 780         .fsctl_fn = skel_fsctl,
 781
 782         /* NT ACL operations. */
 783
 784         .fget_nt_acl_fn = skel_fget_nt_acl,
 785         .get_nt_acl_fn = skel_get_nt_acl,
 786         .fset_nt_acl_fn = skel_fset_nt_acl,
 787
 788         /* POSIX ACL operations. */
 789
 790         .chmod_acl_fn = skel_chmod_acl,
 791         .fchmod_acl_fn = skel_fchmod_acl,
 792
 793         .sys_acl_get_file_fn = skel_sys_acl_get_file,
 794         .sys_acl_get_fd_fn = skel_sys_acl_get_fd,
 795         .sys_acl_blob_get_file_fn = skel_sys_acl_blob_get_file,
 796         .sys_acl_blob_get_fd_fn = skel_sys_acl_blob_get_fd,
 797         .sys_acl_set_file_fn = skel_sys_acl_set_file,
 798         .sys_acl_set_fd_fn = skel_sys_acl_set_fd,
 799         .sys_acl_delete_def_file_fn = skel_sys_acl_delete_def_file,
 800
 801
 802         /* EA operations. */
 803         .getxattr_fn = skel_getxattr,
 804         .fgetxattr_fn = skel_fgetxattr,
 805         .listxattr_fn = skel_listxattr,
 806         .flistxattr_fn = skel_flistxattr,
 807         .removexattr_fn = skel_removexattr,
 808         .fremovexattr_fn = skel_fremovexattr,
 809         .setxattr_fn = skel_setxattr,
 810         .fsetxattr_fn = skel_fsetxattr,
 811
 812         /* aio operations */
 813         .aio_force_fn = skel_aio_force,
 814
 815         /* offline operations */
 816         .is_offline_fn = skel_is_offline,
 817         .set_offline_fn = skel_set_offline
 818 };
 819
 820 NTSTATUS vfs_skel_opaque_init(void)
 821 {
 822         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "skel_opaque", &skel_opaque_fns);
 823 }