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