source3/modules/vfs_not_implemented.c

   1 /*
   2  * VFS module with "not implemented " helper functions for other modules.
   3  *
   4  * Copyright (C) Tim Potter, 1999-2000
   5  * Copyright (C) Alexander Bokovoy, 2002
   6  * Copyright (C) Stefan (metze) Metzmacher, 2003,2018
   7  * Copyright (C) Jeremy Allison 2009
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24 #include "lib/util/tevent_unix.h"
  25 #include "lib/util/tevent_ntstatus.h"
  26
  27 int vfs_not_implemented_connect(
  28                         vfs_handle_struct *handle,
  29                         const char *service,
  30                         const char *user)
  31 {
  32         errno = ENOSYS;
  33         return -1;
  34 }
  35
  36 void vfs_not_implemented_disconnect(vfs_handle_struct *handle)
  37 {
  38         ;
  39 }
  40
  41 uint64_t vfs_not_implemented_disk_free(vfs_handle_struct *handle,
  42                                 const struct smb_filename *smb_fname,
  43                                 uint64_t *bsize,
  44                                 uint64_t *dfree,
  45                                 uint64_t *dsize)
  46 {
  47         *bsize = 0;
  48         *dfree = 0;
  49         *dsize = 0;
  50         return 0;
  51 }
  52
  53 int vfs_not_implemented_get_quota(vfs_handle_struct *handle,
  54                                 const struct smb_filename *smb_fname,
  55                                 enum SMB_QUOTA_TYPE qtype,
  56                                 unid_t id,
  57                                 SMB_DISK_QUOTA *dq)
  58 {
  59         errno = ENOSYS;
  60         return -1;
  61 }
  62
  63 int vfs_not_implemented_set_quota(vfs_handle_struct *handle,
  64                                   enum SMB_QUOTA_TYPE qtype,
  65                                   unid_t id, SMB_DISK_QUOTA *dq)
  66 {
  67         errno = ENOSYS;
  68         return -1;
  69 }
  70
  71 int vfs_not_implemented_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 int vfs_not_implemented_statvfs(struct vfs_handle_struct *handle,
  81                                 const struct smb_filename *smb_fname,
  82                                 struct vfs_statvfs_struct *statbuf)
  83 {
  84         errno = ENOSYS;
  85         return -1;
  86 }
  87
  88 uint32_t vfs_not_implemented_fs_capabilities(struct vfs_handle_struct *handle,
  89                                 enum timestamp_set_resolution *p_ts_res)
  90 {
  91         return 0;
  92 }
  93
  94 NTSTATUS vfs_not_implemented_get_dfs_referrals(struct vfs_handle_struct *handle,
  95                                                struct dfs_GetDFSReferral *r)
  96 {
  97         return NT_STATUS_NOT_IMPLEMENTED;
  98 }
  99
 100 DIR *vfs_not_implemented_opendir(vfs_handle_struct *handle,
 101                         const struct smb_filename *smb_fname,
 102                         const char *mask,
 103                         uint32_t attr)
 104 {
 105         return NULL;
 106 }
 107
 108 NTSTATUS vfs_not_implemented_snap_check_path(struct vfs_handle_struct *handle,
 109                                 TALLOC_CTX *mem_ctx,
 110                                 const char *service_path,
 111                                 char **base_volume)
 112 {
 113         return NT_STATUS_NOT_SUPPORTED;
 114 }
 115
 116 NTSTATUS vfs_not_implemented_snap_create(struct vfs_handle_struct *handle,
 117                                          TALLOC_CTX *mem_ctx,
 118                                          const char *base_volume,
 119                                          time_t *tstamp,
 120                                          bool rw,
 121                                          char **base_path,
 122                                          char **snap_path)
 123 {
 124         return NT_STATUS_NOT_SUPPORTED;
 125 }
 126
 127 NTSTATUS vfs_not_implemented_snap_delete(struct vfs_handle_struct *handle,
 128                                          TALLOC_CTX *mem_ctx,
 129                                          char *base_path,
 130                                          char *snap_path)
 131 {
 132         return NT_STATUS_NOT_SUPPORTED;
 133 }
 134
 135 DIR *vfs_not_implemented_fdopendir(vfs_handle_struct *handle, files_struct *fsp,
 136                                    const char *mask, uint32_t attr)
 137 {
 138         errno = ENOSYS;
 139         return NULL;
 140 }
 141
 142 struct dirent *vfs_not_implemented_readdir(vfs_handle_struct *handle,
 143                                            DIR *dirp, SMB_STRUCT_STAT *sbuf)
 144 {
 145         errno = ENOSYS;
 146         return NULL;
 147 }
 148
 149 void vfs_not_implemented_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
 150 {
 151         ;
 152 }
 153
 154 long vfs_not_implemented_telldir(vfs_handle_struct *handle, DIR *dirp)
 155 {
 156         errno = ENOSYS;
 157         return (long)-1;
 158 }
 159
 160 void vfs_not_implemented_rewind_dir(vfs_handle_struct *handle, DIR *dirp)
 161 {
 162         ;
 163 }
 164
 165 int vfs_not_implemented_mkdir(vfs_handle_struct *handle,
 166                 const struct smb_filename *smb_fname,
 167                 mode_t mode)
 168 {
 169         errno = ENOSYS;
 170         return -1;
 171 }
 172
 173 int vfs_not_implemented_rmdir(vfs_handle_struct *handle,
 174                 const struct smb_filename *smb_fname)
 175 {
 176         errno = ENOSYS;
 177         return -1;
 178 }
 179
 180 int vfs_not_implemented_closedir(vfs_handle_struct *handle, DIR *dir)
 181 {
 182         errno = ENOSYS;
 183         return -1;
 184 }
 185
 186 int vfs_not_implemented_open(vfs_handle_struct *handle,
 187                              struct smb_filename *smb_fname,
 188                              files_struct *fsp, int flags, mode_t mode)
 189 {
 190         errno = ENOSYS;
 191         return -1;
 192 }
 193
 194 NTSTATUS vfs_not_implemented_create_file(struct vfs_handle_struct *handle,
 195                                 struct smb_request *req,
 196                                 uint16_t root_dir_fid,
 197                                 struct smb_filename *smb_fname,
 198                                 uint32_t access_mask,
 199                                 uint32_t share_access,
 200                                 uint32_t create_disposition,
 201                                 uint32_t create_options,
 202                                 uint32_t file_attributes,
 203                                 uint32_t oplock_request,
 204                                 struct smb2_lease *lease,
 205                                 uint64_t allocation_size,
 206                                 uint32_t private_flags,
 207                                 struct security_descriptor *sd,
 208                                 struct ea_list *ea_list,
 209                                 files_struct **result, int *pinfo,
 210                                 const struct smb2_create_blobs *in_context_blobs,
 211                                 struct smb2_create_blobs *out_context_blobs)
 212 {
 213         return NT_STATUS_NOT_IMPLEMENTED;
 214 }
 215
 216 int vfs_not_implemented_close_fn(vfs_handle_struct *handle, files_struct *fsp)
 217 {
 218         errno = ENOSYS;
 219         return -1;
 220 }
 221
 222 ssize_t vfs_not_implemented_pread(vfs_handle_struct *handle, files_struct *fsp,
 223                                   void *data, size_t n, off_t offset)
 224 {
 225         errno = ENOSYS;
 226         return -1;
 227 }
 228
 229 struct tevent_req *vfs_not_implemented_pread_send(struct vfs_handle_struct *handle,
 230                                                   TALLOC_CTX *mem_ctx,
 231                                                   struct tevent_context *ev,
 232                                                   struct files_struct *fsp,
 233                                                   void *data, size_t n, off_t offset)
 234 {
 235         return NULL;
 236 }
 237
 238 ssize_t vfs_not_implemented_pread_recv(struct tevent_req *req,
 239                                        struct vfs_aio_state *vfs_aio_state)
 240 {
 241         vfs_aio_state->error = ENOSYS;
 242         return -1;
 243 }
 244
 245 ssize_t vfs_not_implemented_pwrite(vfs_handle_struct *handle, files_struct *fsp,
 246                                    const void *data, size_t n, off_t offset)
 247 {
 248         errno = ENOSYS;
 249         return -1;
 250 }
 251
 252 struct tevent_req *vfs_not_implemented_pwrite_send(struct vfs_handle_struct *handle,
 253                                                    TALLOC_CTX *mem_ctx,
 254                                                    struct tevent_context *ev,
 255                                                    struct files_struct *fsp,
 256                                                    const void *data,
 257                                                    size_t n, off_t offset)
 258 {
 259         return NULL;
 260 }
 261
 262 ssize_t vfs_not_implemented_pwrite_recv(struct tevent_req *req,
 263                                 struct vfs_aio_state *vfs_aio_state)
 264 {
 265         vfs_aio_state->error = ENOSYS;
 266         return -1;
 267 }
 268
 269 off_t vfs_not_implemented_lseek(vfs_handle_struct *handle, files_struct *fsp,
 270                         off_t offset, int whence)
 271 {
 272         errno = ENOSYS;
 273         return (off_t) - 1;
 274 }
 275
 276 ssize_t vfs_not_implemented_sendfile(vfs_handle_struct *handle, int tofd,
 277                                      files_struct *fromfsp, const DATA_BLOB *hdr,
 278                                      off_t offset, size_t n)
 279 {
 280         errno = ENOSYS;
 281         return -1;
 282 }
 283
 284 ssize_t vfs_not_implemented_recvfile(vfs_handle_struct *handle, int fromfd,
 285                                      files_struct *tofsp, off_t offset, size_t n)
 286 {
 287         errno = ENOSYS;
 288         return -1;
 289 }
 290
 291 int vfs_not_implemented_rename(vfs_handle_struct *handle,
 292                                const struct smb_filename *smb_fname_src,
 293                                const struct smb_filename *smb_fname_dst)
 294 {
 295         errno = ENOSYS;
 296         return -1;
 297 }
 298
 299 struct tevent_req *vfs_not_implemented_fsync_send(struct vfs_handle_struct *handle,
 300                                                   TALLOC_CTX *mem_ctx,
 301                                                   struct tevent_context *ev,
 302                                                   struct files_struct *fsp)
 303 {
 304         return NULL;
 305 }
 306
 307 int vfs_not_implemented_fsync_recv(struct tevent_req *req,
 308                                    struct vfs_aio_state *vfs_aio_state)
 309 {
 310         vfs_aio_state->error = ENOSYS;
 311         return -1;
 312 }
 313
 314 int vfs_not_implemented_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
 315 {
 316         errno = ENOSYS;
 317         return -1;
 318 }
 319
 320 int vfs_not_implemented_fstat(vfs_handle_struct *handle, files_struct *fsp,
 321                         SMB_STRUCT_STAT *sbuf)
 322 {
 323         errno = ENOSYS;
 324         return -1;
 325 }
 326
 327 int vfs_not_implemented_lstat(vfs_handle_struct *handle,
 328                               struct smb_filename *smb_fname)
 329 {
 330         errno = ENOSYS;
 331         return -1;
 332 }
 333
 334 uint64_t vfs_not_implemented_get_alloc_size(struct vfs_handle_struct *handle,
 335                                             struct files_struct *fsp,
 336                                             const SMB_STRUCT_STAT *sbuf)
 337 {
 338         errno = ENOSYS;
 339         return -1;
 340 }
 341
 342 int vfs_not_implemented_unlink(vfs_handle_struct *handle,
 343                                const struct smb_filename *smb_fname)
 344 {
 345         errno = ENOSYS;
 346         return -1;
 347 }
 348
 349 int vfs_not_implemented_chmod(vfs_handle_struct *handle,
 350                               const struct smb_filename *smb_fname,
 351                               mode_t mode)
 352 {
 353         errno = ENOSYS;
 354         return -1;
 355 }
 356
 357 int vfs_not_implemented_fchmod(vfs_handle_struct *handle, files_struct *fsp,
 358                                mode_t mode)
 359 {
 360         errno = ENOSYS;
 361         return -1;
 362 }
 363
 364 int vfs_not_implemented_chown(vfs_handle_struct *handle,
 365                               const struct smb_filename *smb_fname,
 366                               uid_t uid,
 367                               gid_t gid)
 368 {
 369         errno = ENOSYS;
 370         return -1;
 371 }
 372
 373 int vfs_not_implemented_fchown(vfs_handle_struct *handle, files_struct *fsp,
 374                                uid_t uid, gid_t gid)
 375 {
 376         errno = ENOSYS;
 377         return -1;
 378 }
 379
 380 int vfs_not_implemented_lchown(vfs_handle_struct *handle,
 381                                const struct smb_filename *smb_fname,
 382                                uid_t uid,
 383                                gid_t gid)
 384 {
 385         errno = ENOSYS;
 386         return -1;
 387 }
 388
 389 int vfs_not_implemented_chdir(vfs_handle_struct *handle,
 390                               const struct smb_filename *smb_fname)
 391 {
 392         errno = ENOSYS;
 393         return -1;
 394 }
 395
 396 struct smb_filename *vfs_not_implemented_getwd(vfs_handle_struct *handle,
 397                                                TALLOC_CTX *ctx)
 398 {
 399         errno = ENOSYS;
 400         return NULL;
 401 }
 402
 403 int vfs_not_implemented_ntimes(vfs_handle_struct *handle,
 404                                const struct smb_filename *smb_fname,
 405                                struct smb_file_time *ft)
 406 {
 407         errno = ENOSYS;
 408         return -1;
 409 }
 410
 411 int vfs_not_implemented_ftruncate(vfs_handle_struct *handle, files_struct *fsp,
 412                                   off_t offset)
 413 {
 414         errno = ENOSYS;
 415         return -1;
 416 }
 417
 418 int vfs_not_implemented_fallocate(vfs_handle_struct *handle, files_struct *fsp,
 419                                   uint32_t mode, off_t offset, off_t len)
 420 {
 421         errno = ENOSYS;
 422         return -1;
 423 }
 424
 425 bool vfs_not_implemented_lock(vfs_handle_struct *handle, files_struct *fsp, int op,
 426                               off_t offset, off_t count, int type)
 427 {
 428         errno = ENOSYS;
 429         return false;
 430 }
 431
 432 int vfs_not_implemented_kernel_flock(struct vfs_handle_struct *handle,
 433                                      struct files_struct *fsp,
 434                                      uint32_t share_mode, uint32_t access_mask)
 435 {
 436         errno = ENOSYS;
 437         return -1;
 438 }
 439
 440 int vfs_not_implemented_linux_setlease(struct vfs_handle_struct *handle,
 441                                        struct files_struct *fsp, int leasetype)
 442 {
 443         errno = ENOSYS;
 444         return -1;
 445 }
 446
 447 bool vfs_not_implemented_getlock(vfs_handle_struct *handle, files_struct *fsp,
 448                                  off_t *poffset, off_t *pcount, int *ptype,
 449                                  pid_t *ppid)
 450 {
 451         errno = ENOSYS;
 452         return false;
 453 }
 454
 455 int vfs_not_implemented_symlink(vfs_handle_struct *handle,
 456                                 const char *link_contents,
 457                                 const struct smb_filename *new_smb_fname)
 458 {
 459         errno = ENOSYS;
 460         return -1;
 461 }
 462
 463 int vfs_not_implemented_vfs_readlink(vfs_handle_struct *handle,
 464                                      const struct smb_filename *smb_fname,
 465                                      char *buf,
 466                                      size_t bufsiz)
 467 {
 468         errno = ENOSYS;
 469         return -1;
 470 }
 471
 472 int vfs_not_implemented_link(vfs_handle_struct *handle,
 473                              const struct smb_filename *old_smb_fname,
 474                              const struct smb_filename *new_smb_fname)
 475 {
 476         errno = ENOSYS;
 477         return -1;
 478 }
 479
 480 int vfs_not_implemented_mknod(vfs_handle_struct *handle,
 481                               const struct smb_filename *smb_fname,
 482                               mode_t mode,
 483                               SMB_DEV_T dev)
 484 {
 485         errno = ENOSYS;
 486         return -1;
 487 }
 488
 489 struct smb_filename *vfs_not_implemented_realpath(vfs_handle_struct *handle,
 490                                                   TALLOC_CTX *ctx,
 491                                                   const struct smb_filename *smb_fname)
 492 {
 493         errno = ENOSYS;
 494         return NULL;
 495 }
 496
 497 int vfs_not_implemented_chflags(vfs_handle_struct *handle,
 498                                 const struct smb_filename *smb_fname,
 499                                 uint flags)
 500 {
 501         errno = ENOSYS;
 502         return -1;
 503 }
 504
 505 struct file_id vfs_not_implemented_file_id_create(vfs_handle_struct *handle,
 506                                                   const SMB_STRUCT_STAT *sbuf)
 507 {
 508         struct file_id id;
 509         ZERO_STRUCT(id);
 510         errno = ENOSYS;
 511         return id;
 512 }
 513
 514 struct vfs_not_implemented_offload_read_state {
 515         bool dummy;
 516 };
 517
 518 struct tevent_req *vfs_not_implemented_offload_read_send(
 519                         TALLOC_CTX *mem_ctx,
 520                         struct tevent_context *ev,
 521                         struct vfs_handle_struct *handle,
 522                         struct files_struct *fsp,
 523                         uint32_t fsctl,
 524                         uint32_t ttl,
 525                         off_t offset,
 526                         size_t to_copy)
 527 {
 528         struct tevent_req *req = NULL;
 529         struct vfs_not_implemented_offload_read_state *state = NULL;
 530
 531         req = tevent_req_create(mem_ctx, &state,
 532                                 struct vfs_not_implemented_offload_read_state);
 533         if (req == NULL) {
 534                 return NULL;
 535         }
 536
 537         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
 538         return tevent_req_post(req, ev);
 539 }
 540
 541 NTSTATUS vfs_not_implemented_offload_read_recv(struct tevent_req *req,
 542                                        struct vfs_handle_struct *handle,
 543                                        TALLOC_CTX *mem_ctx,
 544                                        DATA_BLOB *_token_blob)
 545 {
 546         NTSTATUS status;
 547
 548         if (tevent_req_is_nterror(req, &status)) {
 549                 tevent_req_received(req);
 550                 return status;
 551         }
 552
 553         tevent_req_received(req);
 554         return NT_STATUS_OK;
 555 }
 556
 557 struct vfs_not_implemented_offload_write_state {
 558         uint64_t unused;
 559 };
 560
 561 struct tevent_req *vfs_not_implemented_offload_write_send(
 562                         struct vfs_handle_struct *handle,
 563                         TALLOC_CTX *mem_ctx,
 564                         struct tevent_context *ev,
 565                         uint32_t fsctl,
 566                         DATA_BLOB *token,
 567                         off_t transfer_offset,
 568                         struct files_struct *dest_fsp,
 569                         off_t dest_off,
 570                         off_t num)
 571 {
 572         struct tevent_req *req;
 573         struct vfs_not_implemented_offload_write_state *state;
 574
 575         req = tevent_req_create(mem_ctx, &state,
 576                                 struct vfs_not_implemented_offload_write_state);
 577         if (req == NULL) {
 578                 return NULL;
 579         }
 580
 581         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
 582         return tevent_req_post(req, ev);
 583 }
 584
 585 NTSTATUS vfs_not_implemented_offload_write_recv(struct vfs_handle_struct *handle,
 586                                                 struct tevent_req *req,
 587                                                 off_t *copied)
 588 {
 589         NTSTATUS status;
 590
 591         if (tevent_req_is_nterror(req, &status)) {
 592                 tevent_req_received(req);
 593                 return status;
 594         }
 595
 596         tevent_req_received(req);
 597         return NT_STATUS_OK;
 598 }
 599
 600 NTSTATUS vfs_not_implemented_get_compression(struct vfs_handle_struct *handle,
 601                                              TALLOC_CTX *mem_ctx,
 602                                              struct files_struct *fsp,
 603                                              struct smb_filename *smb_fname,
 604                                              uint16_t *_compression_fmt)
 605 {
 606         return NT_STATUS_INVALID_DEVICE_REQUEST;
 607 }
 608
 609 NTSTATUS vfs_not_implemented_set_compression(struct vfs_handle_struct *handle,
 610                                              TALLOC_CTX *mem_ctx,
 611                                              struct files_struct *fsp,
 612                                              uint16_t compression_fmt)
 613 {
 614         return NT_STATUS_INVALID_DEVICE_REQUEST;
 615 }
 616
 617 NTSTATUS vfs_not_implemented_streaminfo(struct vfs_handle_struct *handle,
 618                                         struct files_struct *fsp,
 619                                         const struct smb_filename *smb_fname,
 620                                         TALLOC_CTX *mem_ctx,
 621                                         unsigned int *num_streams,
 622                                         struct stream_struct **streams)
 623 {
 624         return NT_STATUS_NOT_IMPLEMENTED;
 625 }
 626
 627 int vfs_not_implemented_get_real_filename(struct vfs_handle_struct *handle,
 628                                           const char *path,
 629                                           const char *name,
 630                                           TALLOC_CTX *mem_ctx,
 631                                           char **found_name)
 632 {
 633         errno = ENOSYS;
 634         return -1;
 635 }
 636
 637 const char *vfs_not_implemented_connectpath(struct vfs_handle_struct *handle,
 638                                             const struct smb_filename *smb_fname)
 639 {
 640         errno = ENOSYS;
 641         return NULL;
 642 }
 643
 644 NTSTATUS vfs_not_implemented_brl_lock_windows(struct vfs_handle_struct *handle,
 645                                               struct byte_range_lock *br_lck,
 646                                               struct lock_struct *plock,
 647                                               bool blocking_lock)
 648 {
 649         return NT_STATUS_NOT_IMPLEMENTED;
 650 }
 651
 652 bool vfs_not_implemented_brl_unlock_windows(struct vfs_handle_struct *handle,
 653                                             struct messaging_context *msg_ctx,
 654                                             struct byte_range_lock *br_lck,
 655                                             const struct lock_struct *plock)
 656 {
 657         errno = ENOSYS;
 658         return false;
 659 }
 660
 661 bool vfs_not_implemented_brl_cancel_windows(struct vfs_handle_struct *handle,
 662                                             struct byte_range_lock *br_lck,
 663                                             struct lock_struct *plock)
 664 {
 665         errno = ENOSYS;
 666         return false;
 667 }
 668
 669 bool vfs_not_implemented_strict_lock_check(struct vfs_handle_struct *handle,
 670                                            struct files_struct *fsp,
 671                                            struct lock_struct *plock)
 672 {
 673         errno = ENOSYS;
 674         return false;
 675 }
 676
 677 NTSTATUS vfs_not_implemented_translate_name(struct vfs_handle_struct *handle,
 678                                             const char *mapped_name,
 679                                             enum vfs_translate_direction direction,
 680                                             TALLOC_CTX *mem_ctx, char **pmapped_name)
 681 {
 682         return NT_STATUS_NOT_IMPLEMENTED;
 683 }
 684
 685 NTSTATUS vfs_not_implemented_fsctl(struct vfs_handle_struct *handle,
 686                                    struct files_struct *fsp,
 687                                    TALLOC_CTX *ctx,
 688                                    uint32_t function,
 689                                    uint16_t req_flags,  /* Needed for UNICODE ... */
 690                                    const uint8_t *_in_data,
 691                                    uint32_t in_len,
 692                                    uint8_t **_out_data,
 693                                    uint32_t max_out_len, uint32_t *out_len)
 694 {
 695         return NT_STATUS_NOT_IMPLEMENTED;
 696 }
 697
 698 NTSTATUS vfs_not_implemented_readdir_attr(struct vfs_handle_struct *handle,
 699                                           const struct smb_filename *fname,
 700                                           TALLOC_CTX *mem_ctx,
 701                                           struct readdir_attr_data **pattr_data)
 702 {
 703         return NT_STATUS_NOT_IMPLEMENTED;
 704 }
 705
 706 NTSTATUS vfs_not_implemented_get_dos_attributes(struct vfs_handle_struct *handle,
 707                                                 struct smb_filename *smb_fname,
 708                                                 uint32_t *dosmode)
 709 {
 710         return NT_STATUS_NOT_IMPLEMENTED;
 711 }
 712
 713 struct vfs_not_implemented_get_dos_attributes_state {
 714         struct vfs_aio_state aio_state;
 715         uint32_t dosmode;
 716 };
 717
 718 struct tevent_req *vfs_not_implemented_get_dos_attributes_send(
 719                         TALLOC_CTX *mem_ctx,
 720                         const struct smb_vfs_ev_glue *evg,
 721                         struct vfs_handle_struct *handle,
 722                         files_struct *dir_fsp,
 723                         struct smb_filename *smb_fname)
 724 {
 725         struct tevent_context *ev = smb_vfs_ev_glue_ev_ctx(evg);
 726         struct tevent_req *req = NULL;
 727         struct vfs_not_implemented_get_dos_attributes_state *state = NULL;
 728
 729         req = tevent_req_create(mem_ctx, &state,
 730                         struct vfs_not_implemented_get_dos_attributes_state);
 731         if (req == NULL) {
 732                 return NULL;
 733         }
 734
 735         tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
 736         return tevent_req_post(req, ev);
 737 }
 738
 739 NTSTATUS vfs_not_implemented_get_dos_attributes_recv(
 740                         struct tevent_req *req,
 741                         struct vfs_aio_state *aio_state,
 742                         uint32_t *dosmode)
 743 {
 744         struct vfs_not_implemented_get_dos_attributes_state *state =
 745                 tevent_req_data(req,
 746                 struct vfs_not_implemented_get_dos_attributes_state);
 747         NTSTATUS status;
 748
 749         if (tevent_req_is_nterror(req, &status)) {
 750                 tevent_req_received(req);
 751                 return status;
 752         }
 753
 754         *aio_state = state->aio_state;
 755         *dosmode = state->dosmode;
 756         tevent_req_received(req);
 757         return NT_STATUS_OK;
 758 }
 759
 760 NTSTATUS vfs_not_implemented_fget_dos_attributes(struct vfs_handle_struct *handle,
 761                                                  struct files_struct *fsp,
 762                                                  uint32_t *dosmode)
 763 {
 764         return NT_STATUS_NOT_IMPLEMENTED;
 765 }
 766
 767 NTSTATUS vfs_not_implemented_set_dos_attributes(struct vfs_handle_struct *handle,
 768                                                 const struct smb_filename *smb_fname,
 769                                                 uint32_t dosmode)
 770 {
 771         return NT_STATUS_NOT_IMPLEMENTED;
 772 }
 773
 774 NTSTATUS vfs_not_implemented_fset_dos_attributes(struct vfs_handle_struct *handle,
 775                                                  struct files_struct *fsp,
 776                                                  uint32_t dosmode)
 777 {
 778         return NT_STATUS_NOT_IMPLEMENTED;
 779 }
 780
 781 NTSTATUS vfs_not_implemented_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 782                                          uint32_t security_info,
 783                                          TALLOC_CTX *mem_ctx,
 784                                          struct security_descriptor **ppdesc)
 785 {
 786         return NT_STATUS_NOT_IMPLEMENTED;
 787 }
 788
 789 NTSTATUS vfs_not_implemented_get_nt_acl(vfs_handle_struct *handle,
 790                                         const struct smb_filename *smb_fname,
 791                                         uint32_t security_info,
 792                                         TALLOC_CTX *mem_ctx,
 793                                         struct security_descriptor **ppdesc)
 794 {
 795         return NT_STATUS_NOT_IMPLEMENTED;
 796 }
 797
 798 NTSTATUS vfs_not_implemented_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
 799                                          uint32_t security_info_sent,
 800                                          const struct security_descriptor *psd)
 801 {
 802         return NT_STATUS_NOT_IMPLEMENTED;
 803 }
 804
 805 SMB_ACL_T vfs_not_implemented_sys_acl_get_file(vfs_handle_struct *handle,
 806                                                const struct smb_filename *smb_fname,
 807                                                SMB_ACL_TYPE_T type,
 808                                                TALLOC_CTX *mem_ctx)
 809 {
 810         errno = ENOSYS;
 811         return (SMB_ACL_T) NULL;
 812 }
 813
 814 SMB_ACL_T vfs_not_implemented_sys_acl_get_fd(vfs_handle_struct *handle,
 815                                              files_struct *fsp, TALLOC_CTX *mem_ctx)
 816 {
 817         errno = ENOSYS;
 818         return (SMB_ACL_T) NULL;
 819 }
 820
 821 int vfs_not_implemented_sys_acl_blob_get_file(vfs_handle_struct *handle,
 822                                 const struct smb_filename *smb_fname,
 823                                 TALLOC_CTX *mem_ctx,
 824                                 char **blob_description,
 825                                 DATA_BLOB *blob)
 826 {
 827         errno = ENOSYS;
 828         return -1;
 829 }
 830
 831 int vfs_not_implemented_sys_acl_blob_get_fd(vfs_handle_struct *handle,
 832                                 files_struct *fsp, TALLOC_CTX *mem_ctx,
 833                                 char **blob_description, DATA_BLOB *blob)
 834 {
 835         errno = ENOSYS;
 836         return -1;
 837 }
 838
 839 int vfs_not_implemented_sys_acl_set_file(vfs_handle_struct *handle,
 840                                 const struct smb_filename *smb_fname,
 841                                 SMB_ACL_TYPE_T acltype,
 842                                 SMB_ACL_T theacl)
 843 {
 844         errno = ENOSYS;
 845         return -1;
 846 }
 847
 848 int vfs_not_implemented_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp,
 849                                        SMB_ACL_T theacl)
 850 {
 851         errno = ENOSYS;
 852         return -1;
 853 }
 854
 855 int vfs_not_implemented_sys_acl_delete_def_file(vfs_handle_struct *handle,
 856                                         const struct smb_filename *smb_fname)
 857 {
 858         errno = ENOSYS;
 859         return -1;
 860 }
 861
 862 ssize_t vfs_not_implemented_getxattr(vfs_handle_struct *handle,
 863                                 const struct smb_filename *smb_fname,
 864                                 const char *name,
 865                                 void *value,
 866                                 size_t size)
 867 {
 868         errno = ENOSYS;
 869         return -1;
 870 }
 871
 872 struct vfs_not_implemented_getxattrat_state {
 873         struct vfs_aio_state aio_state;
 874         ssize_t xattr_size;
 875         uint8_t *xattr_value;
 876 };
 877
 878 struct tevent_req *vfs_not_implemented_getxattrat_send(
 879                         TALLOC_CTX *mem_ctx,
 880                         const struct smb_vfs_ev_glue *evg,
 881                         struct vfs_handle_struct *handle,
 882                         files_struct *dir_fsp,
 883                         const struct smb_filename *smb_fname,
 884                         const char *xattr_name,
 885                         size_t alloc_hint)
 886 {
 887         struct tevent_context *ev = smb_vfs_ev_glue_ev_ctx(evg);
 888         struct tevent_req *req = NULL;
 889         struct vfs_not_implemented_getxattrat_state *state = NULL;
 890
 891         req = tevent_req_create(mem_ctx, &state,
 892                                 struct vfs_not_implemented_getxattrat_state);
 893         if (req == NULL) {
 894                 return NULL;
 895         }
 896
 897         tevent_req_error(req, ENOSYS);
 898         return tevent_req_post(req, ev);
 899 }
 900
 901 ssize_t vfs_not_implemented_getxattrat_recv(struct tevent_req *req,
 902                                     struct vfs_aio_state *aio_state,
 903                                     TALLOC_CTX *mem_ctx,
 904                                     uint8_t **xattr_value)
 905 {
 906         struct vfs_not_implemented_getxattrat_state *state = tevent_req_data(
 907                 req, struct vfs_not_implemented_getxattrat_state);
 908         ssize_t xattr_size;
 909
 910         if (tevent_req_is_unix_error(req, &aio_state->error)) {
 911                 tevent_req_received(req);
 912                 return -1;
 913         }
 914
 915         *aio_state = state->aio_state;
 916         xattr_size = state->xattr_size;
 917         if (xattr_value != NULL) {
 918                 *xattr_value = talloc_move(mem_ctx, &state->xattr_value);
 919         }
 920
 921         tevent_req_received(req);
 922         return xattr_size;
 923 }
 924
 925 ssize_t vfs_not_implemented_fgetxattr(vfs_handle_struct *handle,
 926                               struct files_struct *fsp, const char *name,
 927                               void *value, size_t size)
 928 {
 929         errno = ENOSYS;
 930         return -1;
 931 }
 932
 933 ssize_t vfs_not_implemented_listxattr(vfs_handle_struct *handle,
 934                                       const struct smb_filename *smb_fname,
 935                                       char *list,
 936                                       size_t size)
 937 {
 938         errno = ENOSYS;
 939         return -1;
 940 }
 941
 942 ssize_t vfs_not_implemented_flistxattr(vfs_handle_struct *handle,
 943                                        struct files_struct *fsp, char *list,
 944                                        size_t size)
 945 {
 946         errno = ENOSYS;
 947         return -1;
 948 }
 949
 950 int vfs_not_implemented_removexattr(vfs_handle_struct *handle,
 951                                     const struct smb_filename *smb_fname,
 952                                     const char *name)
 953 {
 954         errno = ENOSYS;
 955         return -1;
 956 }
 957
 958 int vfs_not_implemented_fremovexattr(vfs_handle_struct *handle,
 959                                      struct files_struct *fsp, const char *name)
 960 {
 961         errno = ENOSYS;
 962         return -1;
 963 }
 964
 965 int vfs_not_implemented_setxattr(vfs_handle_struct *handle,
 966                                  const struct smb_filename *smb_fname,
 967                                  const char *name,
 968                                  const void *value,
 969                                  size_t size,
 970                                  int flags)
 971 {
 972         errno = ENOSYS;
 973         return -1;
 974 }
 975
 976 int vfs_not_implemented_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp,
 977                                   const char *name, const void *value, size_t size,
 978                                   int flags)
 979 {
 980         errno = ENOSYS;
 981         return -1;
 982 }
 983
 984 bool vfs_not_implemented_aio_force(struct vfs_handle_struct *handle,
 985                                    struct files_struct *fsp)
 986 {
 987         errno = ENOSYS;
 988         return false;
 989 }
 990
 991 NTSTATUS vfs_not_implemented_audit_file(struct vfs_handle_struct *handle,
 992                                         struct smb_filename *file,
 993                                         struct security_acl *sacl,
 994                                         uint32_t access_requested,
 995                                         uint32_t access_denied)
 996 {
 997         return NT_STATUS_NOT_IMPLEMENTED;
 998 }
 999
1000 NTSTATUS vfs_not_implemented_durable_cookie(struct vfs_handle_struct *handle,
1001                                             struct files_struct *fsp,
1002                                             TALLOC_CTX *mem_ctx,
1003                                             DATA_BLOB *cookie)
1004 {
1005         return NT_STATUS_NOT_IMPLEMENTED;
1006 }
1007
1008 NTSTATUS vfs_not_implemented_durable_disconnect(struct vfs_handle_struct *handle,
1009                                                 struct files_struct *fsp,
1010                                                 const DATA_BLOB old_cookie,
1011                                                 TALLOC_CTX *mem_ctx,
1012                                                 DATA_BLOB *new_cookie)
1013 {
1014         return NT_STATUS_NOT_IMPLEMENTED;
1015 }
1016
1017 NTSTATUS vfs_not_implemented_durable_reconnect(struct vfs_handle_struct *handle,
1018                                                struct smb_request *smb1req,
1019                                                struct smbXsrv_open *op,
1020                                                const DATA_BLOB old_cookie,
1021                                                TALLOC_CTX *mem_ctx,
1022                                                struct files_struct **fsp,
1023                                                DATA_BLOB *new_cookie)
1024 {
1025         return NT_STATUS_NOT_IMPLEMENTED;
1026 }
1027
1028 /* VFS operations structure */
1029
1030 static struct vfs_fn_pointers vfs_not_implemented_fns = {
1031         /* Disk operations */
1032
1033         .connect_fn = vfs_not_implemented_connect,
1034         .disconnect_fn = vfs_not_implemented_disconnect,
1035         .disk_free_fn = vfs_not_implemented_disk_free,
1036         .get_quota_fn = vfs_not_implemented_get_quota,
1037         .set_quota_fn = vfs_not_implemented_set_quota,
1038         .get_shadow_copy_data_fn = vfs_not_implemented_get_shadow_copy_data,
1039         .statvfs_fn = vfs_not_implemented_statvfs,
1040         .fs_capabilities_fn = vfs_not_implemented_fs_capabilities,
1041         .get_dfs_referrals_fn = vfs_not_implemented_get_dfs_referrals,
1042         .snap_check_path_fn = vfs_not_implemented_snap_check_path,
1043         .snap_create_fn = vfs_not_implemented_snap_create,
1044         .snap_delete_fn = vfs_not_implemented_snap_delete,
1045
1046         /* Directory operations */
1047
1048         .opendir_fn = vfs_not_implemented_opendir,
1049         .fdopendir_fn = vfs_not_implemented_fdopendir,
1050         .readdir_fn = vfs_not_implemented_readdir,
1051         .seekdir_fn = vfs_not_implemented_seekdir,
1052         .telldir_fn = vfs_not_implemented_telldir,
1053         .rewind_dir_fn = vfs_not_implemented_rewind_dir,
1054         .mkdir_fn = vfs_not_implemented_mkdir,
1055         .rmdir_fn = vfs_not_implemented_rmdir,
1056         .closedir_fn = vfs_not_implemented_closedir,
1057
1058         /* File operations */
1059
1060         .open_fn = vfs_not_implemented_open,
1061         .create_file_fn = vfs_not_implemented_create_file,
1062         .close_fn = vfs_not_implemented_close_fn,
1063         .pread_fn = vfs_not_implemented_pread,
1064         .pread_send_fn = vfs_not_implemented_pread_send,
1065         .pread_recv_fn = vfs_not_implemented_pread_recv,
1066         .pwrite_fn = vfs_not_implemented_pwrite,
1067         .pwrite_send_fn = vfs_not_implemented_pwrite_send,
1068         .pwrite_recv_fn = vfs_not_implemented_pwrite_recv,
1069         .lseek_fn = vfs_not_implemented_lseek,
1070         .sendfile_fn = vfs_not_implemented_sendfile,
1071         .recvfile_fn = vfs_not_implemented_recvfile,
1072         .rename_fn = vfs_not_implemented_rename,
1073         .fsync_send_fn = vfs_not_implemented_fsync_send,
1074         .fsync_recv_fn = vfs_not_implemented_fsync_recv,
1075         .stat_fn = vfs_not_implemented_stat,
1076         .fstat_fn = vfs_not_implemented_fstat,
1077         .lstat_fn = vfs_not_implemented_lstat,
1078         .get_alloc_size_fn = vfs_not_implemented_get_alloc_size,
1079         .unlink_fn = vfs_not_implemented_unlink,
1080         .chmod_fn = vfs_not_implemented_chmod,
1081         .fchmod_fn = vfs_not_implemented_fchmod,
1082         .chown_fn = vfs_not_implemented_chown,
1083         .fchown_fn = vfs_not_implemented_fchown,
1084         .lchown_fn = vfs_not_implemented_lchown,
1085         .chdir_fn = vfs_not_implemented_chdir,
1086         .getwd_fn = vfs_not_implemented_getwd,
1087         .ntimes_fn = vfs_not_implemented_ntimes,
1088         .ftruncate_fn = vfs_not_implemented_ftruncate,
1089         .fallocate_fn = vfs_not_implemented_fallocate,
1090         .lock_fn = vfs_not_implemented_lock,
1091         .kernel_flock_fn = vfs_not_implemented_kernel_flock,
1092         .linux_setlease_fn = vfs_not_implemented_linux_setlease,
1093         .getlock_fn = vfs_not_implemented_getlock,
1094         .symlink_fn = vfs_not_implemented_symlink,
1095         .readlink_fn = vfs_not_implemented_vfs_readlink,
1096         .link_fn = vfs_not_implemented_link,
1097         .mknod_fn = vfs_not_implemented_mknod,
1098         .realpath_fn = vfs_not_implemented_realpath,
1099         .chflags_fn = vfs_not_implemented_chflags,
1100         .file_id_create_fn = vfs_not_implemented_file_id_create,
1101         .offload_read_send_fn = vfs_not_implemented_offload_read_send,
1102         .offload_read_recv_fn = vfs_not_implemented_offload_read_recv,
1103         .offload_write_send_fn = vfs_not_implemented_offload_write_send,
1104         .offload_write_recv_fn = vfs_not_implemented_offload_write_recv,
1105         .get_compression_fn = vfs_not_implemented_get_compression,
1106         .set_compression_fn = vfs_not_implemented_set_compression,
1107
1108         .streaminfo_fn = vfs_not_implemented_streaminfo,
1109         .get_real_filename_fn = vfs_not_implemented_get_real_filename,
1110         .connectpath_fn = vfs_not_implemented_connectpath,
1111         .brl_lock_windows_fn = vfs_not_implemented_brl_lock_windows,
1112         .brl_unlock_windows_fn = vfs_not_implemented_brl_unlock_windows,
1113         .brl_cancel_windows_fn = vfs_not_implemented_brl_cancel_windows,
1114         .strict_lock_check_fn = vfs_not_implemented_strict_lock_check,
1115         .translate_name_fn = vfs_not_implemented_translate_name,
1116         .fsctl_fn = vfs_not_implemented_fsctl,
1117         .readdir_attr_fn = vfs_not_implemented_readdir_attr,
1118         .audit_file_fn = vfs_not_implemented_audit_file,
1119
1120         /* DOS attributes. */
1121         .get_dos_attributes_fn = vfs_not_implemented_get_dos_attributes,
1122         .get_dos_attributes_send_fn = vfs_not_implemented_get_dos_attributes_send,
1123         .get_dos_attributes_recv_fn = vfs_not_implemented_get_dos_attributes_recv,
1124         .fget_dos_attributes_fn = vfs_not_implemented_fget_dos_attributes,
1125         .set_dos_attributes_fn = vfs_not_implemented_set_dos_attributes,
1126         .fset_dos_attributes_fn = vfs_not_implemented_fset_dos_attributes,
1127
1128         /* NT ACL operations. */
1129
1130         .fget_nt_acl_fn = vfs_not_implemented_fget_nt_acl,
1131         .get_nt_acl_fn = vfs_not_implemented_get_nt_acl,
1132         .fset_nt_acl_fn = vfs_not_implemented_fset_nt_acl,
1133
1134         /* POSIX ACL operations. */
1135
1136         .sys_acl_get_file_fn = vfs_not_implemented_sys_acl_get_file,
1137         .sys_acl_get_fd_fn = vfs_not_implemented_sys_acl_get_fd,
1138         .sys_acl_blob_get_file_fn = vfs_not_implemented_sys_acl_blob_get_file,
1139         .sys_acl_blob_get_fd_fn = vfs_not_implemented_sys_acl_blob_get_fd,
1140         .sys_acl_set_file_fn = vfs_not_implemented_sys_acl_set_file,
1141         .sys_acl_set_fd_fn = vfs_not_implemented_sys_acl_set_fd,
1142         .sys_acl_delete_def_file_fn = vfs_not_implemented_sys_acl_delete_def_file,
1143
1144         /* EA operations. */
1145         .getxattr_fn = vfs_not_implemented_getxattr,
1146         .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
1147         .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
1148         .fgetxattr_fn = vfs_not_implemented_fgetxattr,
1149         .listxattr_fn = vfs_not_implemented_listxattr,
1150         .flistxattr_fn = vfs_not_implemented_flistxattr,
1151         .removexattr_fn = vfs_not_implemented_removexattr,
1152         .fremovexattr_fn = vfs_not_implemented_fremovexattr,
1153         .setxattr_fn = vfs_not_implemented_setxattr,
1154         .fsetxattr_fn = vfs_not_implemented_fsetxattr,
1155
1156         /* aio operations */
1157         .aio_force_fn = vfs_not_implemented_aio_force,
1158
1159         /* durable handle operations */
1160         .durable_cookie_fn = vfs_not_implemented_durable_cookie,
1161         .durable_disconnect_fn = vfs_not_implemented_durable_disconnect,
1162         .durable_reconnect_fn = vfs_not_implemented_durable_reconnect,
1163 };
1164
1165 static_decl_vfs;
1166 NTSTATUS vfs_not_implemented_init(TALLOC_CTX *ctx)
1167 {
1168         /*
1169          * smb_vfs_assert_all_fns() makes sure every
1170          * call is implemented.
1171          */
1172         smb_vfs_assert_all_fns(&vfs_not_implemented_fns, "vfs_not_implemented");
1173         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "vfs_not_implemented",
1174                                 &vfs_not_implemented_fns);
1175 }