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