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