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