source3/modules/vfs_default.c

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