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