source3/modules/vfs_default.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Wrap disk only vfs functions to sidestep dodgy compilers.
   4    Copyright (C) Tim Potter 1998
   5    Copyright (C) Jeremy Allison 2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include "includes.h"
  22
  23 #undef DBGC_CLASS
  24 #define DBGC_CLASS DBGC_VFS
  25
  26 /* Check for NULL pointer parameters in vfswrap_* functions */
  27
  28 /* We don't want to have NULL function pointers lying around.  Someone
  29    is sure to try and execute them.  These stubs are used to prevent
  30    this possibility. */
  31
  32 static int vfswrap_connect(vfs_handle_struct *handle,  const char *service, const char *user)
  33 {
  34     return 0;    /* Return >= 0 for success */
  35 }
  36
  37 static void vfswrap_disconnect(vfs_handle_struct *handle)
  38 {
  39 }
  40
  41 /* Disk operations */
  42
  43 static uint64_t vfswrap_disk_free(vfs_handle_struct *handle,  const char *path, bool small_query, uint64_t *bsize,
  44                                uint64_t *dfree, uint64_t *dsize)
  45 {
  46         uint64_t result;
  47
  48         result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
  49         return result;
  50 }
  51
  52 static int vfswrap_get_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  53 {
  54 #ifdef HAVE_SYS_QUOTAS
  55         int result;
  56
  57         START_PROFILE(syscall_get_quota);
  58         result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
  59         END_PROFILE(syscall_get_quota);
  60         return result;
  61 #else
  62         errno = ENOSYS;
  63         return -1;
  64 #endif
  65 }
  66
  67 static int vfswrap_set_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  68 {
  69 #ifdef HAVE_SYS_QUOTAS
  70         int result;
  71
  72         START_PROFILE(syscall_set_quota);
  73         result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
  74         END_PROFILE(syscall_set_quota);
  75         return result;
  76 #else
  77         errno = ENOSYS;
  78         return -1;
  79 #endif
  80 }
  81
  82 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, bool labels)
  83 {
  84         errno = ENOSYS;
  85         return -1;  /* Not implemented. */
  86 }
  87
  88 static int vfswrap_statvfs(struct vfs_handle_struct *handle,  const char *path, vfs_statvfs_struct *statbuf)
  89 {
  90         return sys_statvfs(path, statbuf);
  91 }
  92
  93 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle)
  94 {
  95 #if defined(DARWINOS)
  96         struct vfs_statvfs_struct statbuf;
  97         ZERO_STRUCT(statbuf);
  98         sys_statvfs(handle->conn->connectpath, &statbuf);
  99         return statbuf.FsCapabilities;
 100 #endif
 101         return FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
 102 }
 103
 104 /* Directory operations */
 105
 106 static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
 107 {
 108         SMB_STRUCT_DIR *result;
 109
 110         START_PROFILE(syscall_opendir);
 111         result = sys_opendir(fname);
 112         END_PROFILE(syscall_opendir);
 113         return result;
 114 }
 115
 116 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle,
 117                                           SMB_STRUCT_DIR *dirp,
 118                                           SMB_STRUCT_STAT *sbuf)
 119 {
 120         SMB_STRUCT_DIRENT *result;
 121
 122         START_PROFILE(syscall_readdir);
 123         result = sys_readdir(dirp);
 124         /* Default Posix readdir() does not give us stat info.
 125          * Set to invalid to indicate we didn't return this info. */
 126         if (sbuf)
 127                 SET_STAT_INVALID(*sbuf);
 128         END_PROFILE(syscall_readdir);
 129         return result;
 130 }
 131
 132 static void vfswrap_seekdir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp, long offset)
 133 {
 134         START_PROFILE(syscall_seekdir);
 135         sys_seekdir(dirp, offset);
 136         END_PROFILE(syscall_seekdir);
 137 }
 138
 139 static long vfswrap_telldir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 140 {
 141         long result;
 142         START_PROFILE(syscall_telldir);
 143         result = sys_telldir(dirp);
 144         END_PROFILE(syscall_telldir);
 145         return result;
 146 }
 147
 148 static void vfswrap_rewinddir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 149 {
 150         START_PROFILE(syscall_rewinddir);
 151         sys_rewinddir(dirp);
 152         END_PROFILE(syscall_rewinddir);
 153 }
 154
 155 static int vfswrap_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
 156 {
 157         int result;
 158         bool has_dacl = False;
 159         char *parent = NULL;
 160
 161         START_PROFILE(syscall_mkdir);
 162
 163         if (lp_inherit_acls(SNUM(handle->conn))
 164             && parent_dirname(talloc_tos(), path, &parent, NULL)
 165             && (has_dacl = directory_has_default_acl(handle->conn, parent)))
 166                 mode = 0777;
 167
 168         TALLOC_FREE(parent);
 169
 170         result = mkdir(path, mode);
 171
 172         if (result == 0 && !has_dacl) {
 173                 /*
 174                  * We need to do this as the default behavior of POSIX ACLs
 175                  * is to set the mask to be the requested group permission
 176                  * bits, not the group permission bits to be the requested
 177                  * group permission bits. This is not what we want, as it will
 178                  * mess up any inherited ACL bits that were set. JRA.
 179                  */
 180                 int saved_errno = errno; /* We may get ENOSYS */
 181                 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
 182                         errno = saved_errno;
 183         }
 184
 185         END_PROFILE(syscall_mkdir);
 186         return result;
 187 }
 188
 189 static int vfswrap_rmdir(vfs_handle_struct *handle,  const char *path)
 190 {
 191         int result;
 192
 193         START_PROFILE(syscall_rmdir);
 194         result = rmdir(path);
 195         END_PROFILE(syscall_rmdir);
 196         return result;
 197 }
 198
 199 static int vfswrap_closedir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 200 {
 201         int result;
 202
 203         START_PROFILE(syscall_closedir);
 204         result = sys_closedir(dirp);
 205         END_PROFILE(syscall_closedir);
 206         return result;
 207 }
 208
 209 static void vfswrap_init_search_op(vfs_handle_struct *handle,
 210                                    SMB_STRUCT_DIR *dirp)
 211 {
 212         /* Default behavior is a NOOP */
 213 }
 214
 215 /* File operations */
 216
 217 static int vfswrap_open(vfs_handle_struct *handle,
 218                         struct smb_filename *smb_fname,
 219                         files_struct *fsp, int flags, mode_t mode)
 220 {
 221         int result;
 222         NTSTATUS status;
 223         char *fname = NULL;
 224
 225         START_PROFILE(syscall_open);
 226
 227         /*
 228          * XXX: Should an error be returned if there is a stream rather than
 229          * trying to open a filename with a ':'?
 230          */
 231         status = get_full_smb_filename(talloc_tos(), smb_fname,
 232                                        &fname);
 233         if (!NT_STATUS_IS_OK(status)) {
 234                 errno = map_errno_from_nt_status(status);
 235                 return -1;
 236         }
 237
 238         result = sys_open(fname, flags, mode);
 239
 240         TALLOC_FREE(fname);
 241
 242         END_PROFILE(syscall_open);
 243         return result;
 244 }
 245
 246 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
 247                                     struct smb_request *req,
 248                                     uint16_t root_dir_fid,
 249                                     struct smb_filename *smb_fname,
 250                                     uint32_t access_mask,
 251                                     uint32_t share_access,
 252                                     uint32_t create_disposition,
 253                                     uint32_t create_options,
 254                                     uint32_t file_attributes,
 255                                     uint32_t oplock_request,
 256                                     uint64_t allocation_size,
 257                                     struct security_descriptor *sd,
 258                                     struct ea_list *ea_list,
 259                                     files_struct **result,
 260                                     int *pinfo)
 261 {
 262         return create_file_default(handle->conn, req, root_dir_fid, smb_fname,
 263                                    access_mask, share_access,
 264                                    create_disposition, create_options,
 265                                    file_attributes, oplock_request,
 266                                    allocation_size, sd, ea_list, result,
 267                                    pinfo);
 268 }
 269
 270 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
 271 {
 272         int result;
 273
 274         START_PROFILE(syscall_close);
 275         result = fd_close_posix(fsp);
 276         END_PROFILE(syscall_close);
 277         return result;
 278 }
 279
 280 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
 281 {
 282         ssize_t result;
 283
 284         START_PROFILE_BYTES(syscall_read, n);
 285         result = sys_read(fsp->fh->fd, data, n);
 286         END_PROFILE(syscall_read);
 287         return result;
 288 }
 289
 290 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
 291                         size_t n, SMB_OFF_T offset)
 292 {
 293         ssize_t result;
 294
 295 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 296         START_PROFILE_BYTES(syscall_pread, n);
 297         result = sys_pread(fsp->fh->fd, data, n, offset);
 298         END_PROFILE(syscall_pread);
 299
 300         if (result == -1 && errno == ESPIPE) {
 301                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 302                 result = SMB_VFS_READ(fsp, data, n);
 303                 fsp->fh->pos = 0;
 304         }
 305
 306 #else /* HAVE_PREAD */
 307         SMB_OFF_T   curr;
 308         int lerrno;
 309
 310         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 311         if (curr == -1 && errno == ESPIPE) {
 312                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 313                 result = SMB_VFS_READ(fsp, data, n);
 314                 fsp->fh->pos = 0;
 315                 return result;
 316         }
 317
 318         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 319                 return -1;
 320         }
 321
 322         errno = 0;
 323         result = SMB_VFS_READ(fsp, data, n);
 324         lerrno = errno;
 325
 326         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 327         errno = lerrno;
 328
 329 #endif /* HAVE_PREAD */
 330
 331         return result;
 332 }
 333
 334 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 335 {
 336         ssize_t result;
 337
 338         START_PROFILE_BYTES(syscall_write, n);
 339         result = sys_write(fsp->fh->fd, data, n);
 340         END_PROFILE(syscall_write);
 341         return result;
 342 }
 343
 344 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
 345                         size_t n, SMB_OFF_T offset)
 346 {
 347         ssize_t result;
 348
 349 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 350         START_PROFILE_BYTES(syscall_pwrite, n);
 351         result = sys_pwrite(fsp->fh->fd, data, n, offset);
 352         END_PROFILE(syscall_pwrite);
 353
 354         if (result == -1 && errno == ESPIPE) {
 355                 /* Maintain the fiction that pipes can be sought on. */
 356                 result = SMB_VFS_WRITE(fsp, data, n);
 357         }
 358
 359 #else /* HAVE_PWRITE */
 360         SMB_OFF_T   curr;
 361         int         lerrno;
 362
 363         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 364         if (curr == -1) {
 365                 return -1;
 366         }
 367
 368         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 369                 return -1;
 370         }
 371
 372         result = SMB_VFS_WRITE(fsp, data, n);
 373         lerrno = errno;
 374
 375         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 376         errno = lerrno;
 377
 378 #endif /* HAVE_PWRITE */
 379
 380         return result;
 381 }
 382
 383 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
 384 {
 385         SMB_OFF_T result = 0;
 386
 387         START_PROFILE(syscall_lseek);
 388
 389         /* Cope with 'stat' file opens. */
 390         if (fsp->fh->fd != -1)
 391                 result = sys_lseek(fsp->fh->fd, offset, whence);
 392
 393         /*
 394          * We want to maintain the fiction that we can seek
 395          * on a fifo for file system purposes. This allows
 396          * people to set up UNIX fifo's that feed data to Windows
 397          * applications. JRA.
 398          */
 399
 400         if((result == -1) && (errno == ESPIPE)) {
 401                 result = 0;
 402                 errno = 0;
 403         }
 404
 405         END_PROFILE(syscall_lseek);
 406         return result;
 407 }
 408
 409 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
 410                         SMB_OFF_T offset, size_t n)
 411 {
 412         ssize_t result;
 413
 414         START_PROFILE_BYTES(syscall_sendfile, n);
 415         result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
 416         END_PROFILE(syscall_sendfile);
 417         return result;
 418 }
 419
 420 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
 421                         int fromfd,
 422                         files_struct *tofsp,
 423                         SMB_OFF_T offset,
 424                         size_t n)
 425 {
 426         ssize_t result;
 427
 428         START_PROFILE_BYTES(syscall_recvfile, n);
 429         result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
 430         END_PROFILE(syscall_recvfile);
 431         return result;
 432 }
 433
 434 /*********************************************************
 435  For rename across filesystems Patch from Warren Birnbaum
 436  <warrenb@hpcvscdp.cv.hp.com>
 437 **********************************************************/
 438
 439 static int copy_reg(const char *source, const char *dest)
 440 {
 441         SMB_STRUCT_STAT source_stats;
 442         int saved_errno;
 443         int ifd = -1;
 444         int ofd = -1;
 445
 446         if (sys_lstat (source, &source_stats) == -1)
 447                 return -1;
 448
 449         if (!S_ISREG (source_stats.st_ex_mode))
 450                 return -1;
 451
 452         if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
 453                 return -1;
 454
 455         if (unlink (dest) && errno != ENOENT)
 456                 return -1;
 457
 458 #ifdef O_NOFOLLOW
 459         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
 460 #else
 461         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
 462 #endif
 463                 goto err;
 464
 465         if (transfer_file(ifd, ofd, (size_t)-1) == -1)
 466                 goto err;
 467
 468         /*
 469          * Try to preserve ownership.  For non-root it might fail, but that's ok.
 470          * But root probably wants to know, e.g. if NFS disallows it.
 471          */
 472
 473 #ifdef HAVE_FCHOWN
 474         if ((fchown(ofd, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
 475 #else
 476         if ((chown(dest, source_stats.st_ex_uid, source_stats.st_ex_gid) == -1) && (errno != EPERM))
 477 #endif
 478                 goto err;
 479
 480         /*
 481          * fchown turns off set[ug]id bits for non-root,
 482          * so do the chmod last.
 483          */
 484
 485 #if defined(HAVE_FCHMOD)
 486         if (fchmod (ofd, source_stats.st_ex_mode & 07777))
 487 #else
 488         if (chmod (dest, source_stats.st_ex_mode & 07777))
 489 #endif
 490                 goto err;
 491
 492         if (close (ifd) == -1)
 493                 goto err;
 494
 495         if (close (ofd) == -1)
 496                 return -1;
 497
 498         /* Try to copy the old file's modtime and access time.  */
 499         {
 500                 struct utimbuf tv;
 501
 502                 tv.actime = convert_timespec_to_time_t(source_stats.st_ex_atime);
 503                 tv.modtime = convert_timespec_to_time_t(source_stats.st_ex_mtime);
 504                 utime(dest, &tv);
 505         }
 506
 507         if (unlink (source) == -1)
 508                 return -1;
 509
 510         return 0;
 511
 512   err:
 513
 514         saved_errno = errno;
 515         if (ifd != -1)
 516                 close(ifd);
 517         if (ofd != -1)
 518                 close(ofd);
 519         errno = saved_errno;
 520         return -1;
 521 }
 522
 523 static int vfswrap_rename(vfs_handle_struct *handle,
 524                           const struct smb_filename *smb_fname_src,
 525                           const struct smb_filename *smb_fname_dst)
 526 {
 527         int result = -1;
 528
 529         START_PROFILE(syscall_rename);
 530
 531         if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
 532                 errno = ENOENT;
 533                 goto out;
 534         }
 535
 536         result = rename(smb_fname_src->base_name, smb_fname_dst->base_name);
 537         if ((result == -1) && (errno == EXDEV)) {
 538                 /* Rename across filesystems needed. */
 539                 result = copy_reg(smb_fname_src->base_name,
 540                                   smb_fname_dst->base_name);
 541         }
 542
 543  out:
 544         END_PROFILE(syscall_rename);
 545         return result;
 546 }
 547
 548 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
 549 {
 550 #ifdef HAVE_FSYNC
 551         int result;
 552
 553         START_PROFILE(syscall_fsync);
 554         result = fsync(fsp->fh->fd);
 555         END_PROFILE(syscall_fsync);
 556         return result;
 557 #else
 558         return 0;
 559 #endif
 560 }
 561
 562 static int vfswrap_stat(vfs_handle_struct *handle,
 563                         struct smb_filename *smb_fname)
 564 {
 565         int result;
 566         NTSTATUS status;
 567         char *fname = NULL;
 568
 569         START_PROFILE(syscall_stat);
 570
 571         status = get_full_smb_filename(talloc_tos(), smb_fname,
 572                                        &fname);
 573         if (!NT_STATUS_IS_OK(status)) {
 574                 errno = map_errno_from_nt_status(status);
 575                 return -1;
 576         }
 577
 578         result = sys_stat(fname, &smb_fname->st);
 579
 580         TALLOC_FREE(fname);
 581
 582         END_PROFILE(syscall_stat);
 583         return result;
 584 }
 585
 586 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 587 {
 588         int result;
 589
 590         START_PROFILE(syscall_fstat);
 591         result = sys_fstat(fsp->fh->fd, sbuf);
 592         END_PROFILE(syscall_fstat);
 593         return result;
 594 }
 595
 596 static int vfswrap_lstat(vfs_handle_struct *handle,
 597                          struct smb_filename *smb_fname)
 598 {
 599         int result;
 600         NTSTATUS status;
 601         char *fname = NULL;
 602
 603         START_PROFILE(syscall_lstat);
 604
 605         status = get_full_smb_filename(talloc_tos(), smb_fname,
 606                                        &fname);
 607         if (!NT_STATUS_IS_OK(status)) {
 608                 errno = map_errno_from_nt_status(status);
 609                 return -1;
 610         }
 611
 612         result = sys_lstat(fname, &smb_fname->st);
 613
 614         TALLOC_FREE(fname);
 615
 616         END_PROFILE(syscall_lstat);
 617         return result;
 618 }
 619
 620 /********************************************************************
 621  Given a stat buffer return the allocated size on disk, taking into
 622  account sparse files.
 623 ********************************************************************/
 624 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
 625                                        struct files_struct *fsp,
 626                                        const SMB_STRUCT_STAT *sbuf)
 627 {
 628         uint64_t result;
 629
 630         START_PROFILE(syscall_get_alloc_size);
 631
 632         if(S_ISDIR(sbuf->st_ex_mode)) {
 633                 result = 0;
 634                 goto out;
 635         }
 636
 637 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
 638         result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
 639 #else
 640         result = get_file_size_stat(sbuf);
 641 #endif
 642
 643         if (fsp && fsp->initial_allocation_size)
 644                 result = MAX(result,fsp->initial_allocation_size);
 645
 646         result = smb_roundup(handle->conn, result);
 647
 648  out:
 649         END_PROFILE(syscall_get_alloc_size);
 650         return result;
 651 }
 652
 653 static int vfswrap_unlink(vfs_handle_struct *handle,
 654                           const struct smb_filename *smb_fname)
 655 {
 656         int result = -1;
 657
 658         START_PROFILE(syscall_unlink);
 659
 660         if (smb_fname->stream_name) {
 661                 errno = ENOENT;
 662                 goto out;
 663         }
 664         result = unlink(smb_fname->base_name);
 665
 666  out:
 667         END_PROFILE(syscall_unlink);
 668         return result;
 669 }
 670
 671 static int vfswrap_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
 672 {
 673         int result;
 674
 675         START_PROFILE(syscall_chmod);
 676
 677         /*
 678          * We need to do this due to the fact that the default POSIX ACL
 679          * chmod modifies the ACL *mask* for the group owner, not the
 680          * group owner bits directly. JRA.
 681          */
 682
 683
 684         {
 685                 int saved_errno = errno; /* We might get ENOSYS */
 686                 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
 687                         END_PROFILE(syscall_chmod);
 688                         return result;
 689                 }
 690                 /* Error - return the old errno. */
 691                 errno = saved_errno;
 692         }
 693
 694         result = chmod(path, mode);
 695         END_PROFILE(syscall_chmod);
 696         return result;
 697 }
 698
 699 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 700 {
 701         int result;
 702
 703         START_PROFILE(syscall_fchmod);
 704
 705         /*
 706          * We need to do this due to the fact that the default POSIX ACL
 707          * chmod modifies the ACL *mask* for the group owner, not the
 708          * group owner bits directly. JRA.
 709          */
 710
 711         {
 712                 int saved_errno = errno; /* We might get ENOSYS */
 713                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
 714                         END_PROFILE(syscall_fchmod);
 715                         return result;
 716                 }
 717                 /* Error - return the old errno. */
 718                 errno = saved_errno;
 719         }
 720
 721 #if defined(HAVE_FCHMOD)
 722         result = fchmod(fsp->fh->fd, mode);
 723 #else
 724         result = -1;
 725         errno = ENOSYS;
 726 #endif
 727
 728         END_PROFILE(syscall_fchmod);
 729         return result;
 730 }
 731
 732 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 733 {
 734         int result;
 735
 736         START_PROFILE(syscall_chown);
 737         result = chown(path, uid, gid);
 738         END_PROFILE(syscall_chown);
 739         return result;
 740 }
 741
 742 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 743 {
 744 #ifdef HAVE_FCHOWN
 745         int result;
 746
 747         START_PROFILE(syscall_fchown);
 748         result = fchown(fsp->fh->fd, uid, gid);
 749         END_PROFILE(syscall_fchown);
 750         return result;
 751 #else
 752         errno = ENOSYS;
 753         return -1;
 754 #endif
 755 }
 756
 757 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 758 {
 759         int result;
 760
 761         START_PROFILE(syscall_lchown);
 762         result = lchown(path, uid, gid);
 763         END_PROFILE(syscall_lchown);
 764         return result;
 765 }
 766
 767 static int vfswrap_chdir(vfs_handle_struct *handle,  const char *path)
 768 {
 769         int result;
 770
 771         START_PROFILE(syscall_chdir);
 772         result = chdir(path);
 773         END_PROFILE(syscall_chdir);
 774         return result;
 775 }
 776
 777 static char *vfswrap_getwd(vfs_handle_struct *handle,  char *path)
 778 {
 779         char *result;
 780
 781         START_PROFILE(syscall_getwd);
 782         result = sys_getwd(path);
 783         END_PROFILE(syscall_getwd);
 784         return result;
 785 }
 786
 787 /*********************************************************************
 788  nsec timestamp resolution call. Convert down to whatever the underlying
 789  system will support.
 790 **********************************************************************/
 791
 792 static int vfswrap_ntimes(vfs_handle_struct *handle,
 793                           const struct smb_filename *smb_fname,
 794                           struct smb_file_time *ft)
 795 {
 796         int result = -1;
 797
 798         START_PROFILE(syscall_ntimes);
 799
 800         if (smb_fname->stream_name) {
 801                 errno = ENOENT;
 802                 goto out;
 803         }
 804
 805 #if defined(HAVE_UTIMES)
 806         if (ft != NULL) {
 807                 struct timeval tv[2];
 808                 tv[0] = convert_timespec_to_timeval(ft->atime);
 809                 tv[1] = convert_timespec_to_timeval(ft->mtime);
 810                 result = utimes(smb_fname->base_name, tv);
 811         } else {
 812                 result = utimes(smb_fname->base_name, NULL);
 813         }
 814 #elif defined(HAVE_UTIME)
 815         if (ft != NULL) {
 816                 struct utimbuf times;
 817                 times.actime = convert_timespec_to_time_t(ft->atime);
 818                 times.modtime = convert_timespec_to_time_t(ft->mtime);
 819                 result = utime(smb_fname->base_name, &times);
 820         } else {
 821                 result = utime(smb_fname->base_name, NULL);
 822         }
 823 #else
 824         errno = ENOSYS;
 825         result = -1;
 826 #endif
 827  out:
 828         END_PROFILE(syscall_ntimes);
 829         return result;
 830 }
 831
 832 /*********************************************************************
 833  A version of ftruncate that will write the space on disk if strict
 834  allocate is set.
 835 **********************************************************************/
 836
 837 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 838 {
 839         SMB_STRUCT_STAT st;
 840         SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 841         unsigned char zero_space[4096];
 842         SMB_OFF_T space_to_write;
 843
 844         if (currpos == -1)
 845                 return -1;
 846
 847         if (SMB_VFS_FSTAT(fsp, &st) == -1)
 848                 return -1;
 849
 850         space_to_write = len - st.st_ex_size;
 851
 852 #ifdef S_ISFIFO
 853         if (S_ISFIFO(st.st_ex_mode))
 854                 return 0;
 855 #endif
 856
 857         if (st.st_ex_size == len)
 858                 return 0;
 859
 860         /* Shrink - just ftruncate. */
 861         if (st.st_ex_size > len)
 862                 return sys_ftruncate(fsp->fh->fd, len);
 863
 864         /* available disk space is enough or not? */
 865         if (lp_strict_allocate(SNUM(fsp->conn))){
 866                 uint64_t space_avail;
 867                 uint64_t bsize,dfree,dsize;
 868
 869                 space_avail = get_dfree_info(fsp->conn,fsp->fsp_name,false,&bsize,&dfree,&dsize);
 870                 /* space_avail is 1k blocks */
 871                 if (space_avail == (uint64_t)-1 ||
 872                                 ((uint64_t)space_to_write/1024 > space_avail) ) {
 873                         errno = ENOSPC;
 874                         return -1;
 875                 }
 876         }
 877
 878         /* Write out the real space on disk. */
 879         if (SMB_VFS_LSEEK(fsp, st.st_ex_size, SEEK_SET) != st.st_ex_size)
 880                 return -1;
 881
 882         space_to_write = len - st.st_ex_size;
 883
 884         memset(zero_space, '\0', sizeof(zero_space));
 885         while ( space_to_write > 0) {
 886                 SMB_OFF_T retlen;
 887                 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 888
 889                 retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
 890                 if (retlen <= 0)
 891                         return -1;
 892
 893                 space_to_write -= retlen;
 894         }
 895
 896         /* Seek to where we were */
 897         if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
 898                 return -1;
 899
 900         return 0;
 901 }
 902
 903 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 904 {
 905         int result = -1;
 906         SMB_STRUCT_STAT st;
 907         char c = 0;
 908         SMB_OFF_T currpos;
 909
 910         START_PROFILE(syscall_ftruncate);
 911
 912         if (lp_strict_allocate(SNUM(fsp->conn))) {
 913                 result = strict_allocate_ftruncate(handle, fsp, len);
 914                 END_PROFILE(syscall_ftruncate);
 915                 return result;
 916         }
 917
 918         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 919            sys_ftruncate if the system supports it. Then I discovered that
 920            you can have some filesystems that support ftruncate
 921            expansion and some that don't! On Linux fat can't do
 922            ftruncate extend but ext2 can. */
 923
 924         result = sys_ftruncate(fsp->fh->fd, len);
 925         if (result == 0)
 926                 goto done;
 927
 928         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 929            extend a file with ftruncate. Provide alternate implementation
 930            for this */
 931         currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 932         if (currpos == -1) {
 933                 goto done;
 934         }
 935
 936         /* Do an fstat to see if the file is longer than the requested
 937            size in which case the ftruncate above should have
 938            succeeded or shorter, in which case seek to len - 1 and
 939            write 1 byte of zero */
 940         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 941                 goto done;
 942         }
 943
 944 #ifdef S_ISFIFO
 945         if (S_ISFIFO(st.st_ex_mode)) {
 946                 result = 0;
 947                 goto done;
 948         }
 949 #endif
 950
 951         if (st.st_ex_size == len) {
 952                 result = 0;
 953                 goto done;
 954         }
 955
 956         if (st.st_ex_size > len) {
 957                 /* the sys_ftruncate should have worked */
 958                 goto done;
 959         }
 960
 961         if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
 962                 goto done;
 963
 964         if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
 965                 goto done;
 966
 967         /* Seek to where we were */
 968         if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
 969                 goto done;
 970         result = 0;
 971
 972   done:
 973
 974         END_PROFILE(syscall_ftruncate);
 975         return result;
 976 }
 977
 978 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 979 {
 980         bool result;
 981
 982         START_PROFILE(syscall_fcntl_lock);
 983         result =  fcntl_lock(fsp->fh->fd, op, offset, count, type);
 984         END_PROFILE(syscall_fcntl_lock);
 985         return result;
 986 }
 987
 988 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
 989                                 uint32 share_mode)
 990 {
 991         START_PROFILE(syscall_kernel_flock);
 992         kernel_flock(fsp->fh->fd, share_mode);
 993         END_PROFILE(syscall_kernel_flock);
 994         return 0;
 995 }
 996
 997 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
 998 {
 999         bool result;
1000
1001         START_PROFILE(syscall_fcntl_getlock);
1002         result =  fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
1003         END_PROFILE(syscall_fcntl_getlock);
1004         return result;
1005 }
1006
1007 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
1008                                 int leasetype)
1009 {
1010         int result = -1;
1011
1012         START_PROFILE(syscall_linux_setlease);
1013
1014 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
1015         /* first set the signal handler */
1016         if(linux_set_lease_sighandler(fsp->fh->fd) == -1) {
1017                 return -1;
1018         }
1019
1020         result = linux_setlease(fsp->fh->fd, leasetype);
1021 #else
1022         errno = ENOSYS;
1023 #endif
1024         END_PROFILE(syscall_linux_setlease);
1025         return result;
1026 }
1027
1028 static int vfswrap_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1029 {
1030         int result;
1031
1032         START_PROFILE(syscall_symlink);
1033         result = symlink(oldpath, newpath);
1034         END_PROFILE(syscall_symlink);
1035         return result;
1036 }
1037
1038 static int vfswrap_readlink(vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
1039 {
1040         int result;
1041
1042         START_PROFILE(syscall_readlink);
1043         result = readlink(path, buf, bufsiz);
1044         END_PROFILE(syscall_readlink);
1045         return result;
1046 }
1047
1048 static int vfswrap_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1049 {
1050         int result;
1051
1052         START_PROFILE(syscall_link);
1053         result = link(oldpath, newpath);
1054         END_PROFILE(syscall_link);
1055         return result;
1056 }
1057
1058 static int vfswrap_mknod(vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
1059 {
1060         int result;
1061
1062         START_PROFILE(syscall_mknod);
1063         result = sys_mknod(pathname, mode, dev);
1064         END_PROFILE(syscall_mknod);
1065         return result;
1066 }
1067
1068 static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path, char *resolved_path)
1069 {
1070         char *result;
1071
1072         START_PROFILE(syscall_realpath);
1073         result = realpath(path, resolved_path);
1074         END_PROFILE(syscall_realpath);
1075         return result;
1076 }
1077
1078 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
1079                                      struct sys_notify_context *ctx,
1080                                      struct notify_entry *e,
1081                                      void (*callback)(struct sys_notify_context *ctx,
1082                                                       void *private_data,
1083                                                       struct notify_event *ev),
1084                                      void *private_data, void *handle)
1085 {
1086         /*
1087          * So far inotify is the only supported default notify mechanism. If
1088          * another platform like the the BSD's or a proprietary Unix comes
1089          * along and wants another default, we can play the same trick we
1090          * played with Posix ACLs.
1091          *
1092          * Until that is the case, hard-code inotify here.
1093          */
1094 #ifdef HAVE_INOTIFY
1095         if (lp_kernel_change_notify(ctx->conn->params)) {
1096                 return inotify_watch(ctx, e, callback, private_data, handle);
1097         }
1098 #endif
1099         /*
1100          * Do nothing, leave everything to notify_internal.c
1101          */
1102         return NT_STATUS_OK;
1103 }
1104
1105 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path,
1106                            unsigned int flags)
1107 {
1108 #ifdef HAVE_CHFLAGS
1109         return chflags(path, flags);
1110 #else
1111         errno = ENOSYS;
1112         return -1;
1113 #endif
1114 }
1115
1116 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
1117                                              const SMB_STRUCT_STAT *sbuf)
1118 {
1119         struct file_id key;
1120
1121         /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1122          * blob */
1123         ZERO_STRUCT(key);
1124
1125         key.devid = sbuf->st_ex_dev;
1126         key.inode = sbuf->st_ex_ino;
1127         /* key.extid is unused by default. */
1128
1129         return key;
1130 }
1131
1132 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1133                                    struct files_struct *fsp,
1134                                    const char *fname,
1135                                    TALLOC_CTX *mem_ctx,
1136                                    unsigned int *pnum_streams,
1137                                    struct stream_struct **pstreams)
1138 {
1139         SMB_STRUCT_STAT sbuf;
1140         unsigned int num_streams = 0;
1141         struct stream_struct *streams = NULL;
1142         int ret;
1143
1144         if ((fsp != NULL) && (fsp->is_directory)) {
1145                 /*
1146                  * No default streams on directories
1147                  */
1148                 goto done;
1149         }
1150
1151         if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1152                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1153         }
1154         else {
1155                 struct smb_filename *smb_fname = NULL;
1156                 NTSTATUS status;
1157
1158                 status = create_synthetic_smb_fname(talloc_tos(), fname, NULL,
1159                                                     NULL, &smb_fname);
1160                 if (!NT_STATUS_IS_OK(status)) {
1161                         return status;
1162                 }
1163                 ret = SMB_VFS_STAT(handle->conn, smb_fname);
1164                 sbuf = smb_fname->st;
1165                 TALLOC_FREE(smb_fname);
1166         }
1167
1168         if (ret == -1) {
1169                 return map_nt_error_from_unix(errno);
1170         }
1171
1172         if (S_ISDIR(sbuf.st_ex_mode)) {
1173                 goto done;
1174         }
1175
1176         streams = talloc(mem_ctx, struct stream_struct);
1177
1178         if (streams == NULL) {
1179                 return NT_STATUS_NO_MEMORY;
1180         }
1181
1182         streams->size = sbuf.st_ex_size;
1183         streams->alloc_size = SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp, &sbuf);
1184
1185         streams->name = talloc_strdup(streams, "::$DATA");
1186         if (streams->name == NULL) {
1187                 TALLOC_FREE(streams);
1188                 return NT_STATUS_NO_MEMORY;
1189         }
1190
1191         num_streams = 1;
1192  done:
1193         *pnum_streams = num_streams;
1194         *pstreams = streams;
1195         return NT_STATUS_OK;
1196 }
1197
1198 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1199                                      const char *path,
1200                                      const char *name,
1201                                      TALLOC_CTX *mem_ctx,
1202                                      char **found_name)
1203 {
1204         /*
1205          * Don't fall back to get_real_filename so callers can differentiate
1206          * between a full directory scan and an actual case-insensitive stat.
1207          */
1208         errno = EOPNOTSUPP;
1209         return -1;
1210 }
1211
1212 static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
1213                                        const char *fname)
1214 {
1215         return handle->conn->connectpath;
1216 }
1217
1218 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
1219                                          struct byte_range_lock *br_lck,
1220                                          struct lock_struct *plock,
1221                                          bool blocking_lock,
1222                                          struct blocking_lock_record *blr)
1223 {
1224         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1225
1226         /* Note: blr is not used in the default implementation. */
1227         return brl_lock_windows_default(br_lck, plock, blocking_lock);
1228 }
1229
1230 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
1231                                        struct messaging_context *msg_ctx,
1232                                        struct byte_range_lock *br_lck,
1233                                        const struct lock_struct *plock)
1234 {
1235         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1236
1237         return brl_unlock_windows_default(msg_ctx, br_lck, plock);
1238 }
1239
1240 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
1241                                        struct byte_range_lock *br_lck,
1242                                        struct lock_struct *plock,
1243                                        struct blocking_lock_record *blr)
1244 {
1245         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1246
1247         /* Note: blr is not used in the default implementation. */
1248         return brl_lock_cancel_default(br_lck, plock);
1249 }
1250
1251 static bool vfswrap_strict_lock(struct vfs_handle_struct *handle,
1252                                 files_struct *fsp,
1253                                 struct lock_struct *plock)
1254 {
1255         SMB_ASSERT(plock->lock_type == READ_LOCK ||
1256             plock->lock_type == WRITE_LOCK);
1257
1258         return strict_lock_default(fsp, plock);
1259 }
1260
1261 static void vfswrap_strict_unlock(struct vfs_handle_struct *handle,
1262                                 files_struct *fsp,
1263                                 struct lock_struct *plock)
1264 {
1265         SMB_ASSERT(plock->lock_type == READ_LOCK ||
1266             plock->lock_type == WRITE_LOCK);
1267
1268         strict_unlock_default(fsp, plock);
1269 }
1270
1271 /* NT ACL operations. */
1272
1273 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1274                                     files_struct *fsp,
1275                                     uint32 security_info, SEC_DESC **ppdesc)
1276 {
1277         NTSTATUS result;
1278
1279         START_PROFILE(fget_nt_acl);
1280         result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1281         END_PROFILE(fget_nt_acl);
1282         return result;
1283 }
1284
1285 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1286                                    const char *name,
1287                                    uint32 security_info, SEC_DESC **ppdesc)
1288 {
1289         NTSTATUS result;
1290
1291         START_PROFILE(get_nt_acl);
1292         result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1293         END_PROFILE(get_nt_acl);
1294         return result;
1295 }
1296
1297 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1298 {
1299         NTSTATUS result;
1300
1301         START_PROFILE(fset_nt_acl);
1302         result = set_nt_acl(fsp, security_info_sent, psd);
1303         END_PROFILE(fset_nt_acl);
1304         return result;
1305 }
1306
1307 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
1308 {
1309 #ifdef HAVE_NO_ACL
1310         errno = ENOSYS;
1311         return -1;
1312 #else
1313         int result;
1314
1315         START_PROFILE(chmod_acl);
1316         result = chmod_acl(handle->conn, name, mode);
1317         END_PROFILE(chmod_acl);
1318         return result;
1319 #endif
1320 }
1321
1322 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1323 {
1324 #ifdef HAVE_NO_ACL
1325         errno = ENOSYS;
1326         return -1;
1327 #else
1328         int result;
1329
1330         START_PROFILE(fchmod_acl);
1331         result = fchmod_acl(fsp, mode);
1332         END_PROFILE(fchmod_acl);
1333         return result;
1334 #endif
1335 }
1336
1337 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1338 {
1339         return sys_acl_get_entry(theacl, entry_id, entry_p);
1340 }
1341
1342 static int vfswrap_sys_acl_get_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_TAG_T *tag_type_p)
1343 {
1344         return sys_acl_get_tag_type(entry_d, tag_type_p);
1345 }
1346
1347 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1348 {
1349         return sys_acl_get_permset(entry_d, permset_p);
1350 }
1351
1352 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
1353 {
1354         return sys_acl_get_qualifier(entry_d);
1355 }
1356
1357 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
1358 {
1359         return sys_acl_get_file(handle, path_p, type);
1360 }
1361
1362 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1363 {
1364         return sys_acl_get_fd(handle, fsp);
1365 }
1366
1367 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
1368 {
1369         return sys_acl_clear_perms(permset);
1370 }
1371
1372 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1373 {
1374         return sys_acl_add_perm(permset, perm);
1375 }
1376
1377 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
1378 {
1379         return sys_acl_to_text(theacl, plen);
1380 }
1381
1382 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle,  int count)
1383 {
1384         return sys_acl_init(count);
1385 }
1386
1387 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1388 {
1389         return sys_acl_create_entry(pacl, pentry);
1390 }
1391
1392 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1393 {
1394         return sys_acl_set_tag_type(entry, tagtype);
1395 }
1396
1397 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
1398 {
1399         return sys_acl_set_qualifier(entry, qual);
1400 }
1401
1402 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1403 {
1404         return sys_acl_set_permset(entry, permset);
1405 }
1406
1407 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
1408 {
1409         return sys_acl_valid(theacl );
1410 }
1411
1412 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1413 {
1414         return sys_acl_set_file(handle, name, acltype, theacl);
1415 }
1416
1417 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1418 {
1419         return sys_acl_set_fd(handle, fsp, theacl);
1420 }
1421
1422 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
1423 {
1424         return sys_acl_delete_def_file(handle, path);
1425 }
1426
1427 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1428 {
1429         return sys_acl_get_perm(permset, perm);
1430 }
1431
1432 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
1433 {
1434         return sys_acl_free_text(text);
1435 }
1436
1437 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
1438 {
1439         return sys_acl_free_acl(posix_acl);
1440 }
1441
1442 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
1443 {
1444         return sys_acl_free_qualifier(qualifier, tagtype);
1445 }
1446
1447 /****************************************************************
1448  Extended attribute operations.
1449 *****************************************************************/
1450
1451 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1452 {
1453         return sys_getxattr(path, name, value, size);
1454 }
1455
1456 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1457 {
1458         return sys_lgetxattr(path, name, value, size);
1459 }
1460
1461 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1462 {
1463         return sys_fgetxattr(fsp->fh->fd, name, value, size);
1464 }
1465
1466 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1467 {
1468         return sys_listxattr(path, list, size);
1469 }
1470
1471 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1472 {
1473         return sys_llistxattr(path, list, size);
1474 }
1475
1476 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1477 {
1478         return sys_flistxattr(fsp->fh->fd, list, size);
1479 }
1480
1481 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1482 {
1483         return sys_removexattr(path, name);
1484 }
1485
1486 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1487 {
1488         return sys_lremovexattr(path, name);
1489 }
1490
1491 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1492 {
1493         return sys_fremovexattr(fsp->fh->fd, name);
1494 }
1495
1496 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1497 {
1498         return sys_setxattr(path, name, value, size, flags);
1499 }
1500
1501 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1502 {
1503         return sys_lsetxattr(path, name, value, size, flags);
1504 }
1505
1506 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1507 {
1508         return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1509 }
1510
1511 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1512 {
1513         int ret;
1514         /*
1515          * aio_read must be done as root, because in the glibc aio
1516          * implementation the helper thread needs to be able to send a signal
1517          * to the main thread, even when it has done a seteuid() to a
1518          * different user.
1519          */
1520         become_root();
1521         ret = sys_aio_read(aiocb);
1522         unbecome_root();
1523         return ret;
1524 }
1525
1526 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1527 {
1528         int ret;
1529         /*
1530          * aio_write must be done as root, because in the glibc aio
1531          * implementation the helper thread needs to be able to send a signal
1532          * to the main thread, even when it has done a seteuid() to a
1533          * different user.
1534          */
1535         become_root();
1536         ret = sys_aio_write(aiocb);
1537         unbecome_root();
1538         return ret;
1539 }
1540
1541 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1542 {
1543         return sys_aio_return(aiocb);
1544 }
1545
1546 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1547 {
1548         return sys_aio_cancel(fsp->fh->fd, aiocb);
1549 }
1550
1551 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1552 {
1553         return sys_aio_error(aiocb);
1554 }
1555
1556 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1557 {
1558         return sys_aio_fsync(op, aiocb);
1559 }
1560
1561 static int vfswrap_aio_suspend(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_AIOCB * const aiocb[], int n, const struct timespec *timeout)
1562 {
1563         return sys_aio_suspend(aiocb, n, timeout);
1564 }
1565
1566 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1567 {
1568         return false;
1569 }
1570
1571 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1572 {
1573         if (ISDOT(path) || ISDOTDOT(path)) {
1574                 return false;
1575         }
1576
1577         if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1578 #if defined(ENOTSUP)
1579                 errno = ENOTSUP;
1580 #endif
1581                 return false;
1582         }
1583
1584         return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1585 }
1586
1587 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1588 {
1589         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1590 #if defined(ENOTSUP)
1591         errno = ENOTSUP;
1592 #endif
1593         return -1;
1594 }
1595
1596 static vfs_op_tuple vfs_default_ops[] = {
1597
1598         /* Disk operations */
1599
1600         {SMB_VFS_OP(vfswrap_connect),   SMB_VFS_OP_CONNECT,
1601          SMB_VFS_LAYER_OPAQUE},
1602         {SMB_VFS_OP(vfswrap_disconnect),        SMB_VFS_OP_DISCONNECT,
1603          SMB_VFS_LAYER_OPAQUE},
1604         {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1605          SMB_VFS_LAYER_OPAQUE},
1606         {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1607          SMB_VFS_LAYER_OPAQUE},
1608         {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1609          SMB_VFS_LAYER_OPAQUE},
1610         {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1611          SMB_VFS_LAYER_OPAQUE},
1612         {SMB_VFS_OP(vfswrap_statvfs),   SMB_VFS_OP_STATVFS,
1613          SMB_VFS_LAYER_OPAQUE},
1614         {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1615          SMB_VFS_LAYER_OPAQUE},
1616
1617         /* Directory operations */
1618
1619         {SMB_VFS_OP(vfswrap_opendir),   SMB_VFS_OP_OPENDIR,
1620          SMB_VFS_LAYER_OPAQUE},
1621         {SMB_VFS_OP(vfswrap_readdir),   SMB_VFS_OP_READDIR,
1622          SMB_VFS_LAYER_OPAQUE},
1623         {SMB_VFS_OP(vfswrap_seekdir),   SMB_VFS_OP_SEEKDIR,
1624          SMB_VFS_LAYER_OPAQUE},
1625         {SMB_VFS_OP(vfswrap_telldir),   SMB_VFS_OP_TELLDIR,
1626          SMB_VFS_LAYER_OPAQUE},
1627         {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1628          SMB_VFS_LAYER_OPAQUE},
1629         {SMB_VFS_OP(vfswrap_mkdir),     SMB_VFS_OP_MKDIR,
1630          SMB_VFS_LAYER_OPAQUE},
1631         {SMB_VFS_OP(vfswrap_rmdir),     SMB_VFS_OP_RMDIR,
1632          SMB_VFS_LAYER_OPAQUE},
1633         {SMB_VFS_OP(vfswrap_closedir),  SMB_VFS_OP_CLOSEDIR,
1634          SMB_VFS_LAYER_OPAQUE},
1635         {SMB_VFS_OP(vfswrap_init_search_op), SMB_VFS_OP_INIT_SEARCH_OP,
1636          SMB_VFS_LAYER_OPAQUE},
1637
1638         /* File operations */
1639
1640         {SMB_VFS_OP(vfswrap_open),      SMB_VFS_OP_OPEN,
1641          SMB_VFS_LAYER_OPAQUE},
1642         {SMB_VFS_OP(vfswrap_create_file),       SMB_VFS_OP_CREATE_FILE,
1643          SMB_VFS_LAYER_OPAQUE},
1644         {SMB_VFS_OP(vfswrap_close),     SMB_VFS_OP_CLOSE,
1645          SMB_VFS_LAYER_OPAQUE},
1646         {SMB_VFS_OP(vfswrap_read),      SMB_VFS_OP_READ,
1647          SMB_VFS_LAYER_OPAQUE},
1648         {SMB_VFS_OP(vfswrap_pread),     SMB_VFS_OP_PREAD,
1649          SMB_VFS_LAYER_OPAQUE},
1650         {SMB_VFS_OP(vfswrap_write),     SMB_VFS_OP_WRITE,
1651          SMB_VFS_LAYER_OPAQUE},
1652         {SMB_VFS_OP(vfswrap_pwrite),    SMB_VFS_OP_PWRITE,
1653          SMB_VFS_LAYER_OPAQUE},
1654         {SMB_VFS_OP(vfswrap_lseek),     SMB_VFS_OP_LSEEK,
1655          SMB_VFS_LAYER_OPAQUE},
1656         {SMB_VFS_OP(vfswrap_sendfile),  SMB_VFS_OP_SENDFILE,
1657          SMB_VFS_LAYER_OPAQUE},
1658         {SMB_VFS_OP(vfswrap_recvfile),  SMB_VFS_OP_RECVFILE,
1659          SMB_VFS_LAYER_OPAQUE},
1660         {SMB_VFS_OP(vfswrap_rename),    SMB_VFS_OP_RENAME,
1661          SMB_VFS_LAYER_OPAQUE},
1662         {SMB_VFS_OP(vfswrap_fsync),     SMB_VFS_OP_FSYNC,
1663          SMB_VFS_LAYER_OPAQUE},
1664         {SMB_VFS_OP(vfswrap_stat),      SMB_VFS_OP_STAT,
1665          SMB_VFS_LAYER_OPAQUE},
1666         {SMB_VFS_OP(vfswrap_fstat),     SMB_VFS_OP_FSTAT,
1667          SMB_VFS_LAYER_OPAQUE},
1668         {SMB_VFS_OP(vfswrap_lstat),     SMB_VFS_OP_LSTAT,
1669          SMB_VFS_LAYER_OPAQUE},
1670         {SMB_VFS_OP(vfswrap_get_alloc_size),    SMB_VFS_OP_GET_ALLOC_SIZE,
1671          SMB_VFS_LAYER_OPAQUE},
1672         {SMB_VFS_OP(vfswrap_unlink),    SMB_VFS_OP_UNLINK,
1673          SMB_VFS_LAYER_OPAQUE},
1674         {SMB_VFS_OP(vfswrap_chmod),     SMB_VFS_OP_CHMOD,
1675          SMB_VFS_LAYER_OPAQUE},
1676         {SMB_VFS_OP(vfswrap_fchmod),    SMB_VFS_OP_FCHMOD,
1677          SMB_VFS_LAYER_OPAQUE},
1678         {SMB_VFS_OP(vfswrap_chown),     SMB_VFS_OP_CHOWN,
1679          SMB_VFS_LAYER_OPAQUE},
1680         {SMB_VFS_OP(vfswrap_fchown),    SMB_VFS_OP_FCHOWN,
1681          SMB_VFS_LAYER_OPAQUE},
1682         {SMB_VFS_OP(vfswrap_lchown),    SMB_VFS_OP_LCHOWN,
1683          SMB_VFS_LAYER_OPAQUE},
1684         {SMB_VFS_OP(vfswrap_chdir),     SMB_VFS_OP_CHDIR,
1685          SMB_VFS_LAYER_OPAQUE},
1686         {SMB_VFS_OP(vfswrap_getwd),     SMB_VFS_OP_GETWD,
1687          SMB_VFS_LAYER_OPAQUE},
1688         {SMB_VFS_OP(vfswrap_ntimes),    SMB_VFS_OP_NTIMES,
1689          SMB_VFS_LAYER_OPAQUE},
1690         {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1691          SMB_VFS_LAYER_OPAQUE},
1692         {SMB_VFS_OP(vfswrap_lock),      SMB_VFS_OP_LOCK,
1693          SMB_VFS_LAYER_OPAQUE},
1694         {SMB_VFS_OP(vfswrap_kernel_flock),      SMB_VFS_OP_KERNEL_FLOCK,
1695          SMB_VFS_LAYER_OPAQUE},
1696         {SMB_VFS_OP(vfswrap_linux_setlease),    SMB_VFS_OP_LINUX_SETLEASE,
1697          SMB_VFS_LAYER_OPAQUE},
1698         {SMB_VFS_OP(vfswrap_getlock),   SMB_VFS_OP_GETLOCK,
1699          SMB_VFS_LAYER_OPAQUE},
1700         {SMB_VFS_OP(vfswrap_symlink),   SMB_VFS_OP_SYMLINK,
1701          SMB_VFS_LAYER_OPAQUE},
1702         {SMB_VFS_OP(vfswrap_readlink),  SMB_VFS_OP_READLINK,
1703          SMB_VFS_LAYER_OPAQUE},
1704         {SMB_VFS_OP(vfswrap_link),      SMB_VFS_OP_LINK,
1705          SMB_VFS_LAYER_OPAQUE},
1706         {SMB_VFS_OP(vfswrap_mknod),     SMB_VFS_OP_MKNOD,
1707          SMB_VFS_LAYER_OPAQUE},
1708         {SMB_VFS_OP(vfswrap_realpath),  SMB_VFS_OP_REALPATH,
1709          SMB_VFS_LAYER_OPAQUE},
1710         {SMB_VFS_OP(vfswrap_notify_watch),      SMB_VFS_OP_NOTIFY_WATCH,
1711          SMB_VFS_LAYER_OPAQUE},
1712         {SMB_VFS_OP(vfswrap_chflags),   SMB_VFS_OP_CHFLAGS,
1713          SMB_VFS_LAYER_OPAQUE},
1714         {SMB_VFS_OP(vfswrap_file_id_create),    SMB_VFS_OP_FILE_ID_CREATE,
1715          SMB_VFS_LAYER_OPAQUE},
1716         {SMB_VFS_OP(vfswrap_streaminfo),        SMB_VFS_OP_STREAMINFO,
1717          SMB_VFS_LAYER_OPAQUE},
1718         {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1719          SMB_VFS_LAYER_OPAQUE},
1720         {SMB_VFS_OP(vfswrap_connectpath),       SMB_VFS_OP_CONNECTPATH,
1721          SMB_VFS_LAYER_OPAQUE},
1722         {SMB_VFS_OP(vfswrap_brl_lock_windows),  SMB_VFS_OP_BRL_LOCK_WINDOWS,
1723          SMB_VFS_LAYER_OPAQUE},
1724         {SMB_VFS_OP(vfswrap_brl_unlock_windows),SMB_VFS_OP_BRL_UNLOCK_WINDOWS,
1725          SMB_VFS_LAYER_OPAQUE},
1726         {SMB_VFS_OP(vfswrap_brl_cancel_windows),SMB_VFS_OP_BRL_CANCEL_WINDOWS,
1727          SMB_VFS_LAYER_OPAQUE},
1728         {SMB_VFS_OP(vfswrap_strict_lock),       SMB_VFS_OP_STRICT_LOCK,
1729          SMB_VFS_LAYER_OPAQUE},
1730         {SMB_VFS_OP(vfswrap_strict_unlock),     SMB_VFS_OP_STRICT_UNLOCK,
1731          SMB_VFS_LAYER_OPAQUE},
1732
1733         /* NT ACL operations. */
1734
1735         {SMB_VFS_OP(vfswrap_fget_nt_acl),       SMB_VFS_OP_FGET_NT_ACL,
1736          SMB_VFS_LAYER_OPAQUE},
1737         {SMB_VFS_OP(vfswrap_get_nt_acl),        SMB_VFS_OP_GET_NT_ACL,
1738          SMB_VFS_LAYER_OPAQUE},
1739         {SMB_VFS_OP(vfswrap_fset_nt_acl),       SMB_VFS_OP_FSET_NT_ACL,
1740          SMB_VFS_LAYER_OPAQUE},
1741
1742         /* POSIX ACL operations. */
1743
1744         {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1745          SMB_VFS_LAYER_OPAQUE},
1746         {SMB_VFS_OP(vfswrap_fchmod_acl),        SMB_VFS_OP_FCHMOD_ACL,
1747          SMB_VFS_LAYER_OPAQUE},
1748         {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1749          SMB_VFS_LAYER_OPAQUE},
1750         {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type),      SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1751          SMB_VFS_LAYER_OPAQUE},
1752         {SMB_VFS_OP(vfswrap_sys_acl_get_permset),       SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1753          SMB_VFS_LAYER_OPAQUE},
1754         {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier),     SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1755          SMB_VFS_LAYER_OPAQUE},
1756         {SMB_VFS_OP(vfswrap_sys_acl_get_file),  SMB_VFS_OP_SYS_ACL_GET_FILE,
1757          SMB_VFS_LAYER_OPAQUE},
1758         {SMB_VFS_OP(vfswrap_sys_acl_get_fd),    SMB_VFS_OP_SYS_ACL_GET_FD,
1759          SMB_VFS_LAYER_OPAQUE},
1760         {SMB_VFS_OP(vfswrap_sys_acl_clear_perms),       SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1761          SMB_VFS_LAYER_OPAQUE},
1762         {SMB_VFS_OP(vfswrap_sys_acl_add_perm),  SMB_VFS_OP_SYS_ACL_ADD_PERM,
1763          SMB_VFS_LAYER_OPAQUE},
1764         {SMB_VFS_OP(vfswrap_sys_acl_to_text),   SMB_VFS_OP_SYS_ACL_TO_TEXT,
1765          SMB_VFS_LAYER_OPAQUE},
1766         {SMB_VFS_OP(vfswrap_sys_acl_init),      SMB_VFS_OP_SYS_ACL_INIT,
1767          SMB_VFS_LAYER_OPAQUE},
1768         {SMB_VFS_OP(vfswrap_sys_acl_create_entry),      SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1769          SMB_VFS_LAYER_OPAQUE},
1770         {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type),      SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1771          SMB_VFS_LAYER_OPAQUE},
1772         {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier),     SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1773          SMB_VFS_LAYER_OPAQUE},
1774         {SMB_VFS_OP(vfswrap_sys_acl_set_permset),       SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1775          SMB_VFS_LAYER_OPAQUE},
1776         {SMB_VFS_OP(vfswrap_sys_acl_valid),     SMB_VFS_OP_SYS_ACL_VALID,
1777          SMB_VFS_LAYER_OPAQUE},
1778         {SMB_VFS_OP(vfswrap_sys_acl_set_file),  SMB_VFS_OP_SYS_ACL_SET_FILE,
1779          SMB_VFS_LAYER_OPAQUE},
1780         {SMB_VFS_OP(vfswrap_sys_acl_set_fd),    SMB_VFS_OP_SYS_ACL_SET_FD,
1781          SMB_VFS_LAYER_OPAQUE},
1782         {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file),   SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1783          SMB_VFS_LAYER_OPAQUE},
1784         {SMB_VFS_OP(vfswrap_sys_acl_get_perm),  SMB_VFS_OP_SYS_ACL_GET_PERM,
1785          SMB_VFS_LAYER_OPAQUE},
1786         {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1787          SMB_VFS_LAYER_OPAQUE},
1788         {SMB_VFS_OP(vfswrap_sys_acl_free_acl),  SMB_VFS_OP_SYS_ACL_FREE_ACL,
1789          SMB_VFS_LAYER_OPAQUE},
1790         {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier),    SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1791          SMB_VFS_LAYER_OPAQUE},
1792
1793         /* EA operations. */
1794
1795         {SMB_VFS_OP(vfswrap_getxattr),  SMB_VFS_OP_GETXATTR,
1796          SMB_VFS_LAYER_OPAQUE},
1797         {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1798          SMB_VFS_LAYER_OPAQUE},
1799         {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1800          SMB_VFS_LAYER_OPAQUE},
1801         {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1802          SMB_VFS_LAYER_OPAQUE},
1803         {SMB_VFS_OP(vfswrap_llistxattr),        SMB_VFS_OP_LLISTXATTR,
1804          SMB_VFS_LAYER_OPAQUE},
1805         {SMB_VFS_OP(vfswrap_flistxattr),        SMB_VFS_OP_FLISTXATTR,
1806          SMB_VFS_LAYER_OPAQUE},
1807         {SMB_VFS_OP(vfswrap_removexattr),       SMB_VFS_OP_REMOVEXATTR,
1808          SMB_VFS_LAYER_OPAQUE},
1809         {SMB_VFS_OP(vfswrap_lremovexattr),      SMB_VFS_OP_LREMOVEXATTR,
1810          SMB_VFS_LAYER_OPAQUE},
1811         {SMB_VFS_OP(vfswrap_fremovexattr),      SMB_VFS_OP_FREMOVEXATTR,
1812          SMB_VFS_LAYER_OPAQUE},
1813         {SMB_VFS_OP(vfswrap_setxattr),  SMB_VFS_OP_SETXATTR,
1814          SMB_VFS_LAYER_OPAQUE},
1815         {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1816          SMB_VFS_LAYER_OPAQUE},
1817         {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1818          SMB_VFS_LAYER_OPAQUE},
1819
1820         {SMB_VFS_OP(vfswrap_aio_read),  SMB_VFS_OP_AIO_READ,
1821          SMB_VFS_LAYER_OPAQUE},
1822         {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1823          SMB_VFS_LAYER_OPAQUE},
1824         {SMB_VFS_OP(vfswrap_aio_return),        SMB_VFS_OP_AIO_RETURN,
1825          SMB_VFS_LAYER_OPAQUE},
1826         {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1827          SMB_VFS_LAYER_OPAQUE},
1828         {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1829          SMB_VFS_LAYER_OPAQUE},
1830         {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1831          SMB_VFS_LAYER_OPAQUE},
1832         {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1833          SMB_VFS_LAYER_OPAQUE},
1834
1835         {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1836          SMB_VFS_LAYER_OPAQUE},
1837
1838         {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1839          SMB_VFS_LAYER_OPAQUE},
1840         {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1841          SMB_VFS_LAYER_OPAQUE},
1842
1843         /* Finish VFS operations definition */
1844
1845         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,
1846          SMB_VFS_LAYER_NOOP}
1847 };
1848
1849 NTSTATUS vfs_default_init(void);
1850 NTSTATUS vfs_default_init(void)
1851 {
1852         unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1853
1854         if (ARRAY_SIZE(vfs_default_ops) != needed) {
1855                 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1856                         DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1857                 smb_panic("operation(s) missing from default VFS module");
1858         }
1859
1860         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1861                                 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1862 }