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