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 SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle,  const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
  44                                SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
  45 {
  46         SMB_BIG_UINT 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 /* Directory operations */
  94
  95 static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
  96 {
  97         SMB_STRUCT_DIR *result;
  98
  99         START_PROFILE(syscall_opendir);
 100         result = sys_opendir(fname);
 101         END_PROFILE(syscall_opendir);
 102         return result;
 103 }
 104
 105 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 106 {
 107         SMB_STRUCT_DIRENT *result;
 108
 109         START_PROFILE(syscall_readdir);
 110         result = sys_readdir(dirp);
 111         END_PROFILE(syscall_readdir);
 112         return result;
 113 }
 114
 115 static void vfswrap_seekdir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp, long offset)
 116 {
 117         START_PROFILE(syscall_seekdir);
 118         sys_seekdir(dirp, offset);
 119         END_PROFILE(syscall_seekdir);
 120 }
 121
 122 static long vfswrap_telldir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 123 {
 124         long result;
 125         START_PROFILE(syscall_telldir);
 126         result = sys_telldir(dirp);
 127         END_PROFILE(syscall_telldir);
 128         return result;
 129 }
 130
 131 static void vfswrap_rewinddir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 132 {
 133         START_PROFILE(syscall_rewinddir);
 134         sys_rewinddir(dirp);
 135         END_PROFILE(syscall_rewinddir);
 136 }
 137
 138 static int vfswrap_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
 139 {
 140         int result;
 141         BOOL has_dacl = False;
 142
 143         START_PROFILE(syscall_mkdir);
 144
 145         if (lp_inherit_acls(SNUM(handle->conn)) && (has_dacl = directory_has_default_acl(handle->conn, parent_dirname(path))))
 146                 mode = 0777;
 147
 148         result = mkdir(path, mode);
 149
 150         if (result == 0 && !has_dacl) {
 151                 /*
 152                  * We need to do this as the default behavior of POSIX ACLs
 153                  * is to set the mask to be the requested group permission
 154                  * bits, not the group permission bits to be the requested
 155                  * group permission bits. This is not what we want, as it will
 156                  * mess up any inherited ACL bits that were set. JRA.
 157                  */
 158                 int saved_errno = errno; /* We may get ENOSYS */
 159                 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
 160                         errno = saved_errno;
 161         }
 162
 163         END_PROFILE(syscall_mkdir);
 164         return result;
 165 }
 166
 167 static int vfswrap_rmdir(vfs_handle_struct *handle,  const char *path)
 168 {
 169         int result;
 170
 171         START_PROFILE(syscall_rmdir);
 172         result = rmdir(path);
 173         END_PROFILE(syscall_rmdir);
 174         return result;
 175 }
 176
 177 static int vfswrap_closedir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 178 {
 179         int result;
 180
 181         START_PROFILE(syscall_closedir);
 182         result = sys_closedir(dirp);
 183         END_PROFILE(syscall_closedir);
 184         return result;
 185 }
 186
 187 /* File operations */
 188
 189 static int vfswrap_open(vfs_handle_struct *handle,  const char *fname,
 190         files_struct *fsp, int flags, mode_t mode)
 191 {
 192         int result;
 193
 194         START_PROFILE(syscall_open);
 195         result = sys_open(fname, flags, mode);
 196         END_PROFILE(syscall_open);
 197         return result;
 198 }
 199
 200 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
 201 {
 202         int result;
 203
 204         START_PROFILE(syscall_close);
 205
 206         result = close(fd);
 207         END_PROFILE(syscall_close);
 208         return result;
 209 }
 210
 211 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
 212 {
 213         ssize_t result;
 214
 215         START_PROFILE_BYTES(syscall_read, n);
 216         result = sys_read(fd, data, n);
 217         END_PROFILE(syscall_read);
 218         return result;
 219 }
 220
 221 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
 222                         size_t n, SMB_OFF_T offset)
 223 {
 224         ssize_t result;
 225
 226 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 227         START_PROFILE_BYTES(syscall_pread, n);
 228         result = sys_pread(fd, data, n, offset);
 229         END_PROFILE(syscall_pread);
 230
 231         if (result == -1 && errno == ESPIPE) {
 232                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 233                 result = SMB_VFS_READ(fsp, fd, data, n);
 234                 fsp->fh->pos = 0;
 235         }
 236
 237 #else /* HAVE_PREAD */
 238         SMB_OFF_T   curr;
 239         int lerrno;
 240
 241         curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 242         if (curr == -1 && errno == ESPIPE) {
 243                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 244                 result = SMB_VFS_READ(fsp, fd, data, n);
 245                 fsp->fh->pos = 0;
 246                 return result;
 247         }
 248
 249         if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
 250                 return -1;
 251         }
 252
 253         errno = 0;
 254         result = SMB_VFS_READ(fsp, fd, data, n);
 255         lerrno = errno;
 256
 257         SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
 258         errno = lerrno;
 259
 260 #endif /* HAVE_PREAD */
 261
 262         return result;
 263 }
 264
 265 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
 266 {
 267         ssize_t result;
 268
 269         START_PROFILE_BYTES(syscall_write, n);
 270         result = sys_write(fd, data, n);
 271         END_PROFILE(syscall_write);
 272         return result;
 273 }
 274
 275 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
 276                         size_t n, SMB_OFF_T offset)
 277 {
 278         ssize_t result;
 279
 280 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 281         START_PROFILE_BYTES(syscall_pwrite, n);
 282         result = sys_pwrite(fd, data, n, offset);
 283         END_PROFILE(syscall_pwrite);
 284
 285         if (result == -1 && errno == ESPIPE) {
 286                 /* Maintain the fiction that pipes can be sought on. */
 287                 result = SMB_VFS_WRITE(fsp, fd, data, n);
 288         }
 289
 290 #else /* HAVE_PWRITE */
 291         SMB_OFF_T   curr;
 292         int         lerrno;
 293
 294         curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 295         if (curr == -1) {
 296                 return -1;
 297         }
 298
 299         if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
 300                 return -1;
 301         }
 302
 303         result = SMB_VFS_WRITE(fsp, fd, data, n);
 304         lerrno = errno;
 305
 306         SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
 307         errno = lerrno;
 308
 309 #endif /* HAVE_PWRITE */
 310
 311         return result;
 312 }
 313
 314 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
 315 {
 316         SMB_OFF_T result = 0;
 317
 318         START_PROFILE(syscall_lseek);
 319
 320         /* Cope with 'stat' file opens. */
 321         if (filedes != -1)
 322                 result = sys_lseek(filedes, offset, whence);
 323
 324         /*
 325          * We want to maintain the fiction that we can seek
 326          * on a fifo for file system purposes. This allows
 327          * people to set up UNIX fifo's that feed data to Windows
 328          * applications. JRA.
 329          */
 330
 331         if((result == -1) && (errno == ESPIPE)) {
 332                 result = 0;
 333                 errno = 0;
 334         }
 335
 336         END_PROFILE(syscall_lseek);
 337         return result;
 338 }
 339
 340 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
 341                         SMB_OFF_T offset, size_t n)
 342 {
 343         ssize_t result;
 344
 345         START_PROFILE_BYTES(syscall_sendfile, n);
 346         result = sys_sendfile(tofd, fromfd, hdr, offset, n);
 347         END_PROFILE(syscall_sendfile);
 348         return result;
 349 }
 350
 351 /*********************************************************
 352  For rename across filesystems Patch from Warren Birnbaum
 353  <warrenb@hpcvscdp.cv.hp.com>
 354 **********************************************************/
 355
 356 static int copy_reg(const char *source, const char *dest)
 357 {
 358         SMB_STRUCT_STAT source_stats;
 359         int saved_errno;
 360         int ifd = -1;
 361         int ofd = -1;
 362
 363         if (sys_lstat (source, &source_stats) == -1)
 364                 return -1;
 365
 366         if (!S_ISREG (source_stats.st_mode))
 367                 return -1;
 368
 369         if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
 370                 return -1;
 371
 372         if (unlink (dest) && errno != ENOENT)
 373                 return -1;
 374
 375 #ifdef O_NOFOLLOW
 376         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
 377 #else
 378         if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
 379 #endif
 380                 goto err;
 381
 382         if (transfer_file(ifd, ofd, (size_t)-1) == -1)
 383                 goto err;
 384
 385         /*
 386          * Try to preserve ownership.  For non-root it might fail, but that's ok.
 387          * But root probably wants to know, e.g. if NFS disallows it.
 388          */
 389
 390 #ifdef HAVE_FCHOWN
 391         if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
 392 #else
 393         if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
 394 #endif
 395                 goto err;
 396
 397         /*
 398          * fchown turns off set[ug]id bits for non-root,
 399          * so do the chmod last.
 400          */
 401
 402 #if defined(HAVE_FCHMOD)
 403         if (fchmod (ofd, source_stats.st_mode & 07777))
 404 #else
 405         if (chmod (dest, source_stats.st_mode & 07777))
 406 #endif
 407                 goto err;
 408
 409         if (close (ifd) == -1)
 410                 goto err;
 411
 412         if (close (ofd) == -1)
 413                 return -1;
 414
 415         /* Try to copy the old file's modtime and access time.  */
 416         {
 417                 struct utimbuf tv;
 418
 419                 tv.actime = source_stats.st_atime;
 420                 tv.modtime = source_stats.st_mtime;
 421                 utime(dest, &tv);
 422         }
 423
 424         if (unlink (source) == -1)
 425                 return -1;
 426
 427         return 0;
 428
 429   err:
 430
 431         saved_errno = errno;
 432         if (ifd != -1)
 433                 close(ifd);
 434         if (ofd != -1)
 435                 close(ofd);
 436         errno = saved_errno;
 437         return -1;
 438 }
 439
 440 static int vfswrap_rename(vfs_handle_struct *handle,  const char *oldname, const char *newname)
 441 {
 442         int result;
 443
 444         START_PROFILE(syscall_rename);
 445         result = rename(oldname, newname);
 446         if (errno == EXDEV) {
 447                 /* Rename across filesystems needed. */
 448                 result = copy_reg(oldname, newname);
 449         }
 450
 451         END_PROFILE(syscall_rename);
 452         return result;
 453 }
 454
 455 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
 456 {
 457 #ifdef HAVE_FSYNC
 458         int result;
 459
 460         START_PROFILE(syscall_fsync);
 461         result = fsync(fd);
 462         END_PROFILE(syscall_fsync);
 463         return result;
 464 #else
 465         return 0;
 466 #endif
 467 }
 468
 469 static int vfswrap_stat(vfs_handle_struct *handle,  const char *fname, SMB_STRUCT_STAT *sbuf)
 470 {
 471         int result;
 472
 473         START_PROFILE(syscall_stat);
 474         result = sys_stat(fname, sbuf);
 475         END_PROFILE(syscall_stat);
 476         return result;
 477 }
 478
 479 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
 480 {
 481         int result;
 482
 483         START_PROFILE(syscall_fstat);
 484         result = sys_fstat(fd, sbuf);
 485         END_PROFILE(syscall_fstat);
 486         return result;
 487 }
 488
 489 int vfswrap_lstat(vfs_handle_struct *handle,  const char *path, SMB_STRUCT_STAT *sbuf)
 490 {
 491         int result;
 492
 493         START_PROFILE(syscall_lstat);
 494         result = sys_lstat(path, sbuf);
 495         END_PROFILE(syscall_lstat);
 496         return result;
 497 }
 498
 499 static int vfswrap_unlink(vfs_handle_struct *handle,  const char *path)
 500 {
 501         int result;
 502
 503         START_PROFILE(syscall_unlink);
 504         result = unlink(path);
 505         END_PROFILE(syscall_unlink);
 506         return result;
 507 }
 508
 509 static int vfswrap_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
 510 {
 511         int result;
 512
 513         START_PROFILE(syscall_chmod);
 514
 515         /*
 516          * We need to do this due to the fact that the default POSIX ACL
 517          * chmod modifies the ACL *mask* for the group owner, not the
 518          * group owner bits directly. JRA.
 519          */
 520
 521
 522         {
 523                 int saved_errno = errno; /* We might get ENOSYS */
 524                 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
 525                         END_PROFILE(syscall_chmod);
 526                         return result;
 527                 }
 528                 /* Error - return the old errno. */
 529                 errno = saved_errno;
 530         }
 531
 532         result = chmod(path, mode);
 533         END_PROFILE(syscall_chmod);
 534         return result;
 535 }
 536
 537 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 538 {
 539         int result;
 540
 541         START_PROFILE(syscall_fchmod);
 542
 543         /*
 544          * We need to do this due to the fact that the default POSIX ACL
 545          * chmod modifies the ACL *mask* for the group owner, not the
 546          * group owner bits directly. JRA.
 547          */
 548
 549         {
 550                 int saved_errno = errno; /* We might get ENOSYS */
 551                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
 552                         END_PROFILE(syscall_fchmod);
 553                         return result;
 554                 }
 555                 /* Error - return the old errno. */
 556                 errno = saved_errno;
 557         }
 558
 559 #if defined(HAVE_FCHMOD)
 560         result = fchmod(fd, mode);
 561 #else
 562         result = -1;
 563         errno = ENOSYS;
 564 #endif
 565
 566         END_PROFILE(syscall_fchmod);
 567         return result;
 568 }
 569
 570 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 571 {
 572         int result;
 573
 574         START_PROFILE(syscall_chown);
 575         result = sys_chown(path, uid, gid);
 576         END_PROFILE(syscall_chown);
 577         return result;
 578 }
 579
 580 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
 581 {
 582 #ifdef HAVE_FCHOWN
 583         int result;
 584
 585         START_PROFILE(syscall_fchown);
 586         result = fchown(fd, uid, gid);
 587         END_PROFILE(syscall_fchown);
 588         return result;
 589 #else
 590         errno = ENOSYS;
 591         return -1;
 592 #endif
 593 }
 594
 595 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 596 {
 597         int result;
 598
 599         START_PROFILE(syscall_lchown);
 600         result = sys_lchown(path, uid, gid);
 601         END_PROFILE(syscall_lchown);
 602         return result;
 603 }
 604
 605 static int vfswrap_chdir(vfs_handle_struct *handle,  const char *path)
 606 {
 607         int result;
 608
 609         START_PROFILE(syscall_chdir);
 610         result = chdir(path);
 611         END_PROFILE(syscall_chdir);
 612         return result;
 613 }
 614
 615 static char *vfswrap_getwd(vfs_handle_struct *handle,  char *path)
 616 {
 617         char *result;
 618
 619         START_PROFILE(syscall_getwd);
 620         result = sys_getwd(path);
 621         END_PROFILE(syscall_getwd);
 622         return result;
 623 }
 624
 625 /*********************************************************************
 626  nsec timestamp resolution call. Convert down to whatever the underlying
 627  system will support.
 628 **********************************************************************/
 629
 630 static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
 631 {
 632         int result;
 633
 634         START_PROFILE(syscall_ntimes);
 635 #if defined(HAVE_UTIMES)
 636         {
 637                 struct timeval tv[2];
 638                 tv[0] = convert_timespec_to_timeval(ts[0]);
 639                 tv[1] = convert_timespec_to_timeval(ts[1]);
 640                 result = utimes(path, tv);
 641         }
 642 #elif defined(HAVE_UTIME)
 643         {
 644                 struct utimbuf times;
 645                 times.actime = convert_timespec_to_time_t(ts[0]);
 646                 times.modtime = convert_timespec_to_time_t(ts[1]);
 647                 result = utime(path, times);
 648         }
 649 #else
 650         errno = ENOSYS;
 651         result = -1;
 652 #endif
 653         END_PROFILE(syscall_ntimes);
 654         return result;
 655 }
 656
 657 /*********************************************************************
 658  A version of ftruncate that will write the space on disk if strict
 659  allocate is set.
 660 **********************************************************************/
 661
 662 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 663 {
 664         SMB_STRUCT_STAT st;
 665         SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 666         unsigned char zero_space[4096];
 667         SMB_OFF_T space_to_write;
 668
 669         if (currpos == -1)
 670                 return -1;
 671
 672         if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
 673                 return -1;
 674
 675         space_to_write = len - st.st_size;
 676
 677 #ifdef S_ISFIFO
 678         if (S_ISFIFO(st.st_mode))
 679                 return 0;
 680 #endif
 681
 682         if (st.st_size == len)
 683                 return 0;
 684
 685         /* Shrink - just ftruncate. */
 686         if (st.st_size > len)
 687                 return sys_ftruncate(fd, len);
 688
 689         /* Write out the real space on disk. */
 690         if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
 691                 return -1;
 692
 693         space_to_write = len - st.st_size;
 694
 695         memset(zero_space, '\0', sizeof(zero_space));
 696         while ( space_to_write > 0) {
 697                 SMB_OFF_T retlen;
 698                 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 699
 700                 retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
 701                 if (retlen <= 0)
 702                         return -1;
 703
 704                 space_to_write -= retlen;
 705         }
 706
 707         /* Seek to where we were */
 708         if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
 709                 return -1;
 710
 711         return 0;
 712 }
 713
 714 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
 715 {
 716         int result = -1;
 717         SMB_STRUCT_STAT st;
 718         char c = 0;
 719         SMB_OFF_T currpos;
 720
 721         START_PROFILE(syscall_ftruncate);
 722
 723         if (lp_strict_allocate(SNUM(fsp->conn))) {
 724                 result = strict_allocate_ftruncate(handle, fsp, fd, len);
 725                 END_PROFILE(syscall_ftruncate);
 726                 return result;
 727         }
 728
 729         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 730            sys_ftruncate if the system supports it. Then I discovered that
 731            you can have some filesystems that support ftruncate
 732            expansion and some that don't! On Linux fat can't do
 733            ftruncate extend but ext2 can. */
 734
 735         result = sys_ftruncate(fd, len);
 736         if (result == 0)
 737                 goto done;
 738
 739         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 740            extend a file with ftruncate. Provide alternate implementation
 741            for this */
 742         currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
 743         if (currpos == -1) {
 744                 goto done;
 745         }
 746
 747         /* Do an fstat to see if the file is longer than the requested
 748            size in which case the ftruncate above should have
 749            succeeded or shorter, in which case seek to len - 1 and
 750            write 1 byte of zero */
 751         if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
 752                 goto done;
 753         }
 754
 755 #ifdef S_ISFIFO
 756         if (S_ISFIFO(st.st_mode)) {
 757                 result = 0;
 758                 goto done;
 759         }
 760 #endif
 761
 762         if (st.st_size == len) {
 763                 result = 0;
 764                 goto done;
 765         }
 766
 767         if (st.st_size > len) {
 768                 /* the sys_ftruncate should have worked */
 769                 goto done;
 770         }
 771
 772         if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
 773                 goto done;
 774
 775         if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
 776                 goto done;
 777
 778         /* Seek to where we were */
 779         if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
 780                 goto done;
 781         result = 0;
 782
 783   done:
 784
 785         END_PROFILE(syscall_ftruncate);
 786         return result;
 787 }
 788
 789 static BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 790 {
 791         BOOL result;
 792
 793         START_PROFILE(syscall_fcntl_lock);
 794
 795         /* SMB_VFS_GETLOCK should be used to query lock status. */
 796         SMB_ASSERT(op != SMB_F_GETLK);
 797
 798         result =  fcntl_lock(fd, op, offset, count, type);
 799         END_PROFILE(syscall_fcntl_lock);
 800         return result;
 801 }
 802
 803 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, int fd,
 804                                 uint32 share_mode)
 805 {
 806         START_PROFILE(syscall_kernel_flock);
 807         kernel_flock(fd, share_mode);
 808         END_PROFILE(syscall_kernel_flock);
 809         return 0;
 810 }
 811
 812 static BOOL vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
 813 {
 814         BOOL result;
 815
 816         START_PROFILE(syscall_fcntl_getlock);
 817         result =  fcntl_getlock(fd, poffset, pcount, ptype, ppid);
 818         END_PROFILE(syscall_fcntl_getlock);
 819         return result;
 820 }
 821
 822 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp, int fd,
 823                                 int leasetype)
 824 {
 825         int result = -1;
 826
 827         START_PROFILE(syscall_linux_setlease);
 828
 829 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
 830         /* first set the signal handler */
 831         if(linux_set_lease_sighandler(fd) == -1) {
 832                 return -1;
 833         }
 834
 835         result = linux_setlease(fd, leasetype);
 836 #else
 837         errno = ENOSYS;
 838 #endif
 839         END_PROFILE(syscall_linux_setlease);
 840         return result;
 841 }
 842
 843 static int vfswrap_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 844 {
 845         int result;
 846
 847         START_PROFILE(syscall_symlink);
 848         result = sys_symlink(oldpath, newpath);
 849         END_PROFILE(syscall_symlink);
 850         return result;
 851 }
 852
 853 static int vfswrap_readlink(vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
 854 {
 855         int result;
 856
 857         START_PROFILE(syscall_readlink);
 858         result = sys_readlink(path, buf, bufsiz);
 859         END_PROFILE(syscall_readlink);
 860         return result;
 861 }
 862
 863 static int vfswrap_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 864 {
 865         int result;
 866
 867         START_PROFILE(syscall_link);
 868         result = sys_link(oldpath, newpath);
 869         END_PROFILE(syscall_link);
 870         return result;
 871 }
 872
 873 static int vfswrap_mknod(vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
 874 {
 875         int result;
 876
 877         START_PROFILE(syscall_mknod);
 878         result = sys_mknod(pathname, mode, dev);
 879         END_PROFILE(syscall_mknod);
 880         return result;
 881 }
 882
 883 static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path, char *resolved_path)
 884 {
 885         char *result;
 886
 887         START_PROFILE(syscall_realpath);
 888         result = sys_realpath(path, resolved_path);
 889         END_PROFILE(syscall_realpath);
 890         return result;
 891 }
 892
 893 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
 894                                      struct sys_notify_context *ctx,
 895                                      struct notify_entry *e,
 896                                      void (*callback)(struct sys_notify_context *ctx,
 897                                                       void *private_data,
 898                                                       struct notify_event *ev),
 899                                      void *private_data, void *handle)
 900 {
 901         /*
 902          * So far inotify is the only supported default notify mechanism. If
 903          * another platform like the the BSD's or a proprietary Unix comes
 904          * along and wants another default, we can play the same trick we
 905          * played with Posix ACLs.
 906          *
 907          * Until that is the case, hard-code inotify here.
 908          */
 909 #ifdef HAVE_INOTIFY
 910         if (lp_kernel_change_notify(ctx->conn->params)) {
 911                 return inotify_watch(ctx, e, callback, private_data, handle);
 912         }
 913 #endif
 914         /*
 915          * Do nothing, leave everything to notify_internal.c
 916          */
 917         return NT_STATUS_OK;
 918 }
 919
 920 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
 921 {
 922 #ifdef HAVE_CHFLAGS
 923         return chflags(path, flags);
 924 #else
 925         errno = ENOSYS;
 926         return -1;
 927 #endif
 928 }
 929
 930 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
 931 {
 932         return file_id_create_dev(dev, inode);
 933 }
 934
 935 static size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info, SEC_DESC **ppdesc)
 936 {
 937         size_t result;
 938
 939         START_PROFILE(fget_nt_acl);
 940         result = get_nt_acl(fsp, security_info, ppdesc);
 941         END_PROFILE(fget_nt_acl);
 942         return result;
 943 }
 944
 945 static size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info, SEC_DESC **ppdesc)
 946 {
 947         size_t result;
 948
 949         START_PROFILE(get_nt_acl);
 950         result = get_nt_acl(fsp, security_info, ppdesc);
 951         END_PROFILE(get_nt_acl);
 952         return result;
 953 }
 954
 955 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
 956 {
 957         NTSTATUS result;
 958
 959         START_PROFILE(fset_nt_acl);
 960         result = set_nt_acl(fsp, security_info_sent, psd);
 961         END_PROFILE(fset_nt_acl);
 962         return result;
 963 }
 964
 965 static NTSTATUS vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
 966 {
 967         NTSTATUS result;
 968
 969         START_PROFILE(set_nt_acl);
 970         result = set_nt_acl(fsp, security_info_sent, psd);
 971         END_PROFILE(set_nt_acl);
 972         return result;
 973 }
 974
 975 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
 976 {
 977 #ifdef HAVE_NO_ACL
 978         errno = ENOSYS;
 979         return -1;
 980 #else
 981         int result;
 982
 983         START_PROFILE(chmod_acl);
 984         result = chmod_acl(handle->conn, name, mode);
 985         END_PROFILE(chmod_acl);
 986         return result;
 987 #endif
 988 }
 989
 990 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
 991 {
 992 #ifdef HAVE_NO_ACL
 993         errno = ENOSYS;
 994         return -1;
 995 #else
 996         int result;
 997
 998         START_PROFILE(fchmod_acl);
 999         result = fchmod_acl(fsp, fd, mode);
1000         END_PROFILE(fchmod_acl);
1001         return result;
1002 #endif
1003 }
1004
1005 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1006 {
1007         return sys_acl_get_entry(theacl, entry_id, entry_p);
1008 }
1009
1010 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)
1011 {
1012         return sys_acl_get_tag_type(entry_d, tag_type_p);
1013 }
1014
1015 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1016 {
1017         return sys_acl_get_permset(entry_d, permset_p);
1018 }
1019
1020 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
1021 {
1022         return sys_acl_get_qualifier(entry_d);
1023 }
1024
1025 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
1026 {
1027         return sys_acl_get_file(handle, path_p, type);
1028 }
1029
1030 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
1031 {
1032         return sys_acl_get_fd(handle, fsp, fd);
1033 }
1034
1035 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
1036 {
1037         return sys_acl_clear_perms(permset);
1038 }
1039
1040 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1041 {
1042         return sys_acl_add_perm(permset, perm);
1043 }
1044
1045 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
1046 {
1047         return sys_acl_to_text(theacl, plen);
1048 }
1049
1050 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle,  int count)
1051 {
1052         return sys_acl_init(count);
1053 }
1054
1055 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1056 {
1057         return sys_acl_create_entry(pacl, pentry);
1058 }
1059
1060 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1061 {
1062         return sys_acl_set_tag_type(entry, tagtype);
1063 }
1064
1065 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
1066 {
1067         return sys_acl_set_qualifier(entry, qual);
1068 }
1069
1070 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1071 {
1072         return sys_acl_set_permset(entry, permset);
1073 }
1074
1075 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
1076 {
1077         return sys_acl_valid(theacl );
1078 }
1079
1080 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1081 {
1082         return sys_acl_set_file(handle, name, acltype, theacl);
1083 }
1084
1085 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
1086 {
1087         return sys_acl_set_fd(handle, fsp, fd, theacl);
1088 }
1089
1090 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
1091 {
1092         return sys_acl_delete_def_file(handle, path);
1093 }
1094
1095 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1096 {
1097         return sys_acl_get_perm(permset, perm);
1098 }
1099
1100 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
1101 {
1102         return sys_acl_free_text(text);
1103 }
1104
1105 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
1106 {
1107         return sys_acl_free_acl(posix_acl);
1108 }
1109
1110 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
1111 {
1112         return sys_acl_free_qualifier(qualifier, tagtype);
1113 }
1114
1115 /****************************************************************
1116  Extended attribute operations.
1117 *****************************************************************/
1118
1119 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1120 {
1121         return sys_getxattr(path, name, value, size);
1122 }
1123
1124 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1125 {
1126         return sys_lgetxattr(path, name, value, size);
1127 }
1128
1129 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, void *value, size_t size)
1130 {
1131         return sys_fgetxattr(fd, name, value, size);
1132 }
1133
1134 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1135 {
1136         return sys_listxattr(path, list, size);
1137 }
1138
1139 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1140 {
1141         return sys_llistxattr(path, list, size);
1142 }
1143
1144 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, char *list, size_t size)
1145 {
1146         return sys_flistxattr(fd, list, size);
1147 }
1148
1149 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1150 {
1151         return sys_removexattr(path, name);
1152 }
1153
1154 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1155 {
1156         return sys_lremovexattr(path, name);
1157 }
1158
1159 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name)
1160 {
1161         return sys_fremovexattr(fd, name);
1162 }
1163
1164 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1165 {
1166         return sys_setxattr(path, name, value, size, flags);
1167 }
1168
1169 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1170 {
1171         return sys_lsetxattr(path, name, value, size, flags);
1172 }
1173
1174 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, const void *value, size_t size, int flags)
1175 {
1176         return sys_fsetxattr(fd, name, value, size, flags);
1177 }
1178
1179 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1180 {
1181         return sys_aio_read(aiocb);
1182 }
1183
1184 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1185 {
1186         return sys_aio_write(aiocb);
1187 }
1188
1189 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1190 {
1191         return sys_aio_return(aiocb);
1192 }
1193
1194 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_AIOCB *aiocb)
1195 {
1196         return sys_aio_cancel(fd, aiocb);
1197 }
1198
1199 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1200 {
1201         return sys_aio_error(aiocb);
1202 }
1203
1204 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1205 {
1206         return sys_aio_fsync(op, aiocb);
1207 }
1208
1209 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)
1210 {
1211         return sys_aio_suspend(aiocb, n, timeout);
1212 }
1213
1214 static vfs_op_tuple vfs_default_ops[] = {
1215
1216         /* Disk operations */
1217
1218         {SMB_VFS_OP(vfswrap_connect),   SMB_VFS_OP_CONNECT,
1219          SMB_VFS_LAYER_OPAQUE},
1220         {SMB_VFS_OP(vfswrap_disconnect),        SMB_VFS_OP_DISCONNECT,
1221          SMB_VFS_LAYER_OPAQUE},
1222         {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1223          SMB_VFS_LAYER_OPAQUE},
1224         {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1225          SMB_VFS_LAYER_OPAQUE},
1226         {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1227          SMB_VFS_LAYER_OPAQUE},
1228         {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1229          SMB_VFS_LAYER_OPAQUE},
1230         {SMB_VFS_OP(vfswrap_statvfs),   SMB_VFS_OP_STATVFS,
1231          SMB_VFS_LAYER_OPAQUE},
1232
1233         /* Directory operations */
1234
1235         {SMB_VFS_OP(vfswrap_opendir),   SMB_VFS_OP_OPENDIR,
1236          SMB_VFS_LAYER_OPAQUE},
1237         {SMB_VFS_OP(vfswrap_readdir),   SMB_VFS_OP_READDIR,
1238          SMB_VFS_LAYER_OPAQUE},
1239         {SMB_VFS_OP(vfswrap_seekdir),   SMB_VFS_OP_SEEKDIR,
1240          SMB_VFS_LAYER_OPAQUE},
1241         {SMB_VFS_OP(vfswrap_telldir),   SMB_VFS_OP_TELLDIR,
1242          SMB_VFS_LAYER_OPAQUE},
1243         {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1244          SMB_VFS_LAYER_OPAQUE},
1245         {SMB_VFS_OP(vfswrap_mkdir),     SMB_VFS_OP_MKDIR,
1246          SMB_VFS_LAYER_OPAQUE},
1247         {SMB_VFS_OP(vfswrap_rmdir),     SMB_VFS_OP_RMDIR,
1248          SMB_VFS_LAYER_OPAQUE},
1249         {SMB_VFS_OP(vfswrap_closedir),  SMB_VFS_OP_CLOSEDIR,
1250          SMB_VFS_LAYER_OPAQUE},
1251
1252         /* File operations */
1253
1254         {SMB_VFS_OP(vfswrap_open),      SMB_VFS_OP_OPEN,
1255          SMB_VFS_LAYER_OPAQUE},
1256         {SMB_VFS_OP(vfswrap_close),     SMB_VFS_OP_CLOSE,
1257          SMB_VFS_LAYER_OPAQUE},
1258         {SMB_VFS_OP(vfswrap_read),      SMB_VFS_OP_READ,
1259          SMB_VFS_LAYER_OPAQUE},
1260         {SMB_VFS_OP(vfswrap_pread),     SMB_VFS_OP_PREAD,
1261          SMB_VFS_LAYER_OPAQUE},
1262         {SMB_VFS_OP(vfswrap_write),     SMB_VFS_OP_WRITE,
1263          SMB_VFS_LAYER_OPAQUE},
1264         {SMB_VFS_OP(vfswrap_pwrite),    SMB_VFS_OP_PWRITE,
1265          SMB_VFS_LAYER_OPAQUE},
1266         {SMB_VFS_OP(vfswrap_lseek),     SMB_VFS_OP_LSEEK,
1267          SMB_VFS_LAYER_OPAQUE},
1268         {SMB_VFS_OP(vfswrap_sendfile),  SMB_VFS_OP_SENDFILE,
1269          SMB_VFS_LAYER_OPAQUE},
1270         {SMB_VFS_OP(vfswrap_rename),    SMB_VFS_OP_RENAME,
1271          SMB_VFS_LAYER_OPAQUE},
1272         {SMB_VFS_OP(vfswrap_fsync),     SMB_VFS_OP_FSYNC,
1273          SMB_VFS_LAYER_OPAQUE},
1274         {SMB_VFS_OP(vfswrap_stat),      SMB_VFS_OP_STAT,
1275          SMB_VFS_LAYER_OPAQUE},
1276         {SMB_VFS_OP(vfswrap_fstat),     SMB_VFS_OP_FSTAT,
1277          SMB_VFS_LAYER_OPAQUE},
1278         {SMB_VFS_OP(vfswrap_lstat),     SMB_VFS_OP_LSTAT,
1279          SMB_VFS_LAYER_OPAQUE},
1280         {SMB_VFS_OP(vfswrap_unlink),    SMB_VFS_OP_UNLINK,
1281          SMB_VFS_LAYER_OPAQUE},
1282         {SMB_VFS_OP(vfswrap_chmod),     SMB_VFS_OP_CHMOD,
1283          SMB_VFS_LAYER_OPAQUE},
1284         {SMB_VFS_OP(vfswrap_fchmod),    SMB_VFS_OP_FCHMOD,
1285          SMB_VFS_LAYER_OPAQUE},
1286         {SMB_VFS_OP(vfswrap_chown),     SMB_VFS_OP_CHOWN,
1287          SMB_VFS_LAYER_OPAQUE},
1288         {SMB_VFS_OP(vfswrap_fchown),    SMB_VFS_OP_FCHOWN,
1289          SMB_VFS_LAYER_OPAQUE},
1290         {SMB_VFS_OP(vfswrap_lchown),    SMB_VFS_OP_LCHOWN,
1291          SMB_VFS_LAYER_OPAQUE},
1292         {SMB_VFS_OP(vfswrap_chdir),     SMB_VFS_OP_CHDIR,
1293          SMB_VFS_LAYER_OPAQUE},
1294         {SMB_VFS_OP(vfswrap_getwd),     SMB_VFS_OP_GETWD,
1295          SMB_VFS_LAYER_OPAQUE},
1296         {SMB_VFS_OP(vfswrap_ntimes),    SMB_VFS_OP_NTIMES,
1297          SMB_VFS_LAYER_OPAQUE},
1298         {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1299          SMB_VFS_LAYER_OPAQUE},
1300         {SMB_VFS_OP(vfswrap_lock),      SMB_VFS_OP_LOCK,
1301          SMB_VFS_LAYER_OPAQUE},
1302         {SMB_VFS_OP(vfswrap_kernel_flock),      SMB_VFS_OP_KERNEL_FLOCK,
1303          SMB_VFS_LAYER_OPAQUE},
1304         {SMB_VFS_OP(vfswrap_linux_setlease),    SMB_VFS_OP_LINUX_SETLEASE,
1305          SMB_VFS_LAYER_OPAQUE},
1306         {SMB_VFS_OP(vfswrap_getlock),   SMB_VFS_OP_GETLOCK,
1307          SMB_VFS_LAYER_OPAQUE},
1308         {SMB_VFS_OP(vfswrap_symlink),   SMB_VFS_OP_SYMLINK,
1309          SMB_VFS_LAYER_OPAQUE},
1310         {SMB_VFS_OP(vfswrap_readlink),  SMB_VFS_OP_READLINK,
1311          SMB_VFS_LAYER_OPAQUE},
1312         {SMB_VFS_OP(vfswrap_link),      SMB_VFS_OP_LINK,
1313          SMB_VFS_LAYER_OPAQUE},
1314         {SMB_VFS_OP(vfswrap_mknod),     SMB_VFS_OP_MKNOD,
1315          SMB_VFS_LAYER_OPAQUE},
1316         {SMB_VFS_OP(vfswrap_realpath),  SMB_VFS_OP_REALPATH,
1317          SMB_VFS_LAYER_OPAQUE},
1318         {SMB_VFS_OP(vfswrap_notify_watch),      SMB_VFS_OP_NOTIFY_WATCH,
1319          SMB_VFS_LAYER_OPAQUE},
1320         {SMB_VFS_OP(vfswrap_chflags),   SMB_VFS_OP_CHFLAGS,
1321          SMB_VFS_LAYER_OPAQUE},
1322         {SMB_VFS_OP(vfswrap_file_id_create),    SMB_VFS_OP_FILE_ID_CREATE,
1323          SMB_VFS_LAYER_OPAQUE},
1324
1325         /* NT ACL operations. */
1326
1327         {SMB_VFS_OP(vfswrap_fget_nt_acl),       SMB_VFS_OP_FGET_NT_ACL,
1328          SMB_VFS_LAYER_OPAQUE},
1329         {SMB_VFS_OP(vfswrap_get_nt_acl),        SMB_VFS_OP_GET_NT_ACL,
1330          SMB_VFS_LAYER_OPAQUE},
1331         {SMB_VFS_OP(vfswrap_fset_nt_acl),       SMB_VFS_OP_FSET_NT_ACL,
1332          SMB_VFS_LAYER_OPAQUE},
1333         {SMB_VFS_OP(vfswrap_set_nt_acl),        SMB_VFS_OP_SET_NT_ACL,
1334          SMB_VFS_LAYER_OPAQUE},
1335
1336         /* POSIX ACL operations. */
1337
1338         {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1339          SMB_VFS_LAYER_OPAQUE},
1340         {SMB_VFS_OP(vfswrap_fchmod_acl),        SMB_VFS_OP_FCHMOD_ACL,
1341          SMB_VFS_LAYER_OPAQUE},
1342         {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1343          SMB_VFS_LAYER_OPAQUE},
1344         {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type),      SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1345          SMB_VFS_LAYER_OPAQUE},
1346         {SMB_VFS_OP(vfswrap_sys_acl_get_permset),       SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1347          SMB_VFS_LAYER_OPAQUE},
1348         {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier),     SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1349          SMB_VFS_LAYER_OPAQUE},
1350         {SMB_VFS_OP(vfswrap_sys_acl_get_file),  SMB_VFS_OP_SYS_ACL_GET_FILE,
1351          SMB_VFS_LAYER_OPAQUE},
1352         {SMB_VFS_OP(vfswrap_sys_acl_get_fd),    SMB_VFS_OP_SYS_ACL_GET_FD,
1353          SMB_VFS_LAYER_OPAQUE},
1354         {SMB_VFS_OP(vfswrap_sys_acl_clear_perms),       SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1355          SMB_VFS_LAYER_OPAQUE},
1356         {SMB_VFS_OP(vfswrap_sys_acl_add_perm),  SMB_VFS_OP_SYS_ACL_ADD_PERM,
1357          SMB_VFS_LAYER_OPAQUE},
1358         {SMB_VFS_OP(vfswrap_sys_acl_to_text),   SMB_VFS_OP_SYS_ACL_TO_TEXT,
1359          SMB_VFS_LAYER_OPAQUE},
1360         {SMB_VFS_OP(vfswrap_sys_acl_init),      SMB_VFS_OP_SYS_ACL_INIT,
1361          SMB_VFS_LAYER_OPAQUE},
1362         {SMB_VFS_OP(vfswrap_sys_acl_create_entry),      SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1363          SMB_VFS_LAYER_OPAQUE},
1364         {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type),      SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1365          SMB_VFS_LAYER_OPAQUE},
1366         {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier),     SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1367          SMB_VFS_LAYER_OPAQUE},
1368         {SMB_VFS_OP(vfswrap_sys_acl_set_permset),       SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1369          SMB_VFS_LAYER_OPAQUE},
1370         {SMB_VFS_OP(vfswrap_sys_acl_valid),     SMB_VFS_OP_SYS_ACL_VALID,
1371          SMB_VFS_LAYER_OPAQUE},
1372         {SMB_VFS_OP(vfswrap_sys_acl_set_file),  SMB_VFS_OP_SYS_ACL_SET_FILE,
1373          SMB_VFS_LAYER_OPAQUE},
1374         {SMB_VFS_OP(vfswrap_sys_acl_set_fd),    SMB_VFS_OP_SYS_ACL_SET_FD,
1375          SMB_VFS_LAYER_OPAQUE},
1376         {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file),   SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1377          SMB_VFS_LAYER_OPAQUE},
1378         {SMB_VFS_OP(vfswrap_sys_acl_get_perm),  SMB_VFS_OP_SYS_ACL_GET_PERM,
1379          SMB_VFS_LAYER_OPAQUE},
1380         {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1381          SMB_VFS_LAYER_OPAQUE},
1382         {SMB_VFS_OP(vfswrap_sys_acl_free_acl),  SMB_VFS_OP_SYS_ACL_FREE_ACL,
1383          SMB_VFS_LAYER_OPAQUE},
1384         {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier),    SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1385          SMB_VFS_LAYER_OPAQUE},
1386
1387         /* EA operations. */
1388
1389         {SMB_VFS_OP(vfswrap_getxattr),  SMB_VFS_OP_GETXATTR,
1390          SMB_VFS_LAYER_OPAQUE},
1391         {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1392          SMB_VFS_LAYER_OPAQUE},
1393         {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1394          SMB_VFS_LAYER_OPAQUE},
1395         {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1396          SMB_VFS_LAYER_OPAQUE},
1397         {SMB_VFS_OP(vfswrap_llistxattr),        SMB_VFS_OP_LLISTXATTR,
1398          SMB_VFS_LAYER_OPAQUE},
1399         {SMB_VFS_OP(vfswrap_flistxattr),        SMB_VFS_OP_FLISTXATTR,
1400          SMB_VFS_LAYER_OPAQUE},
1401         {SMB_VFS_OP(vfswrap_removexattr),       SMB_VFS_OP_REMOVEXATTR,
1402          SMB_VFS_LAYER_OPAQUE},
1403         {SMB_VFS_OP(vfswrap_lremovexattr),      SMB_VFS_OP_LREMOVEXATTR,
1404          SMB_VFS_LAYER_OPAQUE},
1405         {SMB_VFS_OP(vfswrap_fremovexattr),      SMB_VFS_OP_FREMOVEXATTR,
1406          SMB_VFS_LAYER_OPAQUE},
1407         {SMB_VFS_OP(vfswrap_setxattr),  SMB_VFS_OP_SETXATTR,
1408          SMB_VFS_LAYER_OPAQUE},
1409         {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1410          SMB_VFS_LAYER_OPAQUE},
1411         {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1412          SMB_VFS_LAYER_OPAQUE},
1413
1414         {SMB_VFS_OP(vfswrap_aio_read),  SMB_VFS_OP_AIO_READ,
1415          SMB_VFS_LAYER_OPAQUE},
1416         {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1417          SMB_VFS_LAYER_OPAQUE},
1418         {SMB_VFS_OP(vfswrap_aio_return),        SMB_VFS_OP_AIO_RETURN,
1419          SMB_VFS_LAYER_OPAQUE},
1420         {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1421          SMB_VFS_LAYER_OPAQUE},
1422         {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1423          SMB_VFS_LAYER_OPAQUE},
1424         {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1425          SMB_VFS_LAYER_OPAQUE},
1426         {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1427          SMB_VFS_LAYER_OPAQUE},
1428
1429         /* Finish VFS operations definition */
1430
1431         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,
1432          SMB_VFS_LAYER_NOOP}
1433 };
1434
1435 NTSTATUS vfs_default_init(void);
1436 NTSTATUS vfs_default_init(void)
1437 {
1438         unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1439
1440         if (ARRAY_SIZE(vfs_default_ops) != needed) {
1441                 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1442                         DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1443                 smb_panic("operation(s) missing from default VFS module");
1444         }
1445
1446         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1447                                 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1448 }