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,
 686                           struct smb_file_time *ft)
 687 {
 688         int result;
 689
 690         START_PROFILE(syscall_ntimes);
 691 #if defined(HAVE_UTIMES)
 692         if (ft != NULL) {
 693                 struct timeval tv[2];
 694                 tv[0] = convert_timespec_to_timeval(ft->atime);
 695                 tv[1] = convert_timespec_to_timeval(ft->mtime);
 696                 result = utimes(path, tv);
 697         } else {
 698                 result = utimes(path, NULL);
 699         }
 700 #elif defined(HAVE_UTIME)
 701         if (ft != NULL) {
 702                 struct utimbuf times;
 703                 times.actime = convert_timespec_to_time_t(ft->atime);
 704                 times.modtime = convert_timespec_to_time_t(ft->mtime);
 705                 result = utime(path, times);
 706         } else {
 707                 result = utime(path, NULL);
 708         }
 709 #else
 710         errno = ENOSYS;
 711         result = -1;
 712 #endif
 713         END_PROFILE(syscall_ntimes);
 714         return result;
 715 }
 716
 717 /*********************************************************************
 718  A version of ftruncate that will write the space on disk if strict
 719  allocate is set.
 720 **********************************************************************/
 721
 722 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 723 {
 724         SMB_STRUCT_STAT st;
 725         SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 726         unsigned char zero_space[4096];
 727         SMB_OFF_T space_to_write;
 728
 729         if (currpos == -1)
 730                 return -1;
 731
 732         if (SMB_VFS_FSTAT(fsp, &st) == -1)
 733                 return -1;
 734
 735         space_to_write = len - st.st_size;
 736
 737 #ifdef S_ISFIFO
 738         if (S_ISFIFO(st.st_mode))
 739                 return 0;
 740 #endif
 741
 742         if (st.st_size == len)
 743                 return 0;
 744
 745         /* Shrink - just ftruncate. */
 746         if (st.st_size > len)
 747                 return sys_ftruncate(fsp->fh->fd, len);
 748
 749         /* available disk space is enough or not? */
 750         if (lp_strict_allocate(SNUM(fsp->conn))){
 751                 uint64_t space_avail;
 752                 uint64_t bsize,dfree,dsize;
 753
 754                 space_avail = get_dfree_info(fsp->conn,fsp->fsp_name,false,&bsize,&dfree,&dsize);
 755                 /* space_avail is 1k blocks */
 756                 if (space_avail == (uint64_t)-1 ||
 757                                 ((uint64_t)space_to_write/1024 > space_avail) ) {
 758                         errno = ENOSPC;
 759                         return -1;
 760                 }
 761         }
 762
 763         /* Write out the real space on disk. */
 764         if (SMB_VFS_LSEEK(fsp, st.st_size, SEEK_SET) != st.st_size)
 765                 return -1;
 766
 767         space_to_write = len - st.st_size;
 768
 769         memset(zero_space, '\0', sizeof(zero_space));
 770         while ( space_to_write > 0) {
 771                 SMB_OFF_T retlen;
 772                 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
 773
 774                 retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
 775                 if (retlen <= 0)
 776                         return -1;
 777
 778                 space_to_write -= retlen;
 779         }
 780
 781         /* Seek to where we were */
 782         if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
 783                 return -1;
 784
 785         return 0;
 786 }
 787
 788 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 789 {
 790         int result = -1;
 791         SMB_STRUCT_STAT st;
 792         char c = 0;
 793         SMB_OFF_T currpos;
 794
 795         START_PROFILE(syscall_ftruncate);
 796
 797         if (lp_strict_allocate(SNUM(fsp->conn))) {
 798                 result = strict_allocate_ftruncate(handle, fsp, len);
 799                 END_PROFILE(syscall_ftruncate);
 800                 return result;
 801         }
 802
 803         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 804            sys_ftruncate if the system supports it. Then I discovered that
 805            you can have some filesystems that support ftruncate
 806            expansion and some that don't! On Linux fat can't do
 807            ftruncate extend but ext2 can. */
 808
 809         result = sys_ftruncate(fsp->fh->fd, len);
 810         if (result == 0)
 811                 goto done;
 812
 813         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 814            extend a file with ftruncate. Provide alternate implementation
 815            for this */
 816         currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 817         if (currpos == -1) {
 818                 goto done;
 819         }
 820
 821         /* Do an fstat to see if the file is longer than the requested
 822            size in which case the ftruncate above should have
 823            succeeded or shorter, in which case seek to len - 1 and
 824            write 1 byte of zero */
 825         if (SMB_VFS_FSTAT(fsp, &st) == -1) {
 826                 goto done;
 827         }
 828
 829 #ifdef S_ISFIFO
 830         if (S_ISFIFO(st.st_mode)) {
 831                 result = 0;
 832                 goto done;
 833         }
 834 #endif
 835
 836         if (st.st_size == len) {
 837                 result = 0;
 838                 goto done;
 839         }
 840
 841         if (st.st_size > len) {
 842                 /* the sys_ftruncate should have worked */
 843                 goto done;
 844         }
 845
 846         if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
 847                 goto done;
 848
 849         if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
 850                 goto done;
 851
 852         /* Seek to where we were */
 853         if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
 854                 goto done;
 855         result = 0;
 856
 857   done:
 858
 859         END_PROFILE(syscall_ftruncate);
 860         return result;
 861 }
 862
 863 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
 864 {
 865         bool result;
 866
 867         START_PROFILE(syscall_fcntl_lock);
 868         result =  fcntl_lock(fsp->fh->fd, op, offset, count, type);
 869         END_PROFILE(syscall_fcntl_lock);
 870         return result;
 871 }
 872
 873 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
 874                                 uint32 share_mode)
 875 {
 876         START_PROFILE(syscall_kernel_flock);
 877         kernel_flock(fsp->fh->fd, share_mode);
 878         END_PROFILE(syscall_kernel_flock);
 879         return 0;
 880 }
 881
 882 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
 883 {
 884         bool result;
 885
 886         START_PROFILE(syscall_fcntl_getlock);
 887         result =  fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
 888         END_PROFILE(syscall_fcntl_getlock);
 889         return result;
 890 }
 891
 892 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
 893                                 int leasetype)
 894 {
 895         int result = -1;
 896
 897         START_PROFILE(syscall_linux_setlease);
 898
 899 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
 900         /* first set the signal handler */
 901         if(linux_set_lease_sighandler(fsp->fh->fd) == -1) {
 902                 return -1;
 903         }
 904
 905         result = linux_setlease(fsp->fh->fd, leasetype);
 906 #else
 907         errno = ENOSYS;
 908 #endif
 909         END_PROFILE(syscall_linux_setlease);
 910         return result;
 911 }
 912
 913 static int vfswrap_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 914 {
 915         int result;
 916
 917         START_PROFILE(syscall_symlink);
 918         result = symlink(oldpath, newpath);
 919         END_PROFILE(syscall_symlink);
 920         return result;
 921 }
 922
 923 static int vfswrap_readlink(vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
 924 {
 925         int result;
 926
 927         START_PROFILE(syscall_readlink);
 928         result = readlink(path, buf, bufsiz);
 929         END_PROFILE(syscall_readlink);
 930         return result;
 931 }
 932
 933 static int vfswrap_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
 934 {
 935         int result;
 936
 937         START_PROFILE(syscall_link);
 938         result = link(oldpath, newpath);
 939         END_PROFILE(syscall_link);
 940         return result;
 941 }
 942
 943 static int vfswrap_mknod(vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
 944 {
 945         int result;
 946
 947         START_PROFILE(syscall_mknod);
 948         result = sys_mknod(pathname, mode, dev);
 949         END_PROFILE(syscall_mknod);
 950         return result;
 951 }
 952
 953 static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path, char *resolved_path)
 954 {
 955         char *result;
 956
 957         START_PROFILE(syscall_realpath);
 958         result = realpath(path, resolved_path);
 959         END_PROFILE(syscall_realpath);
 960         return result;
 961 }
 962
 963 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
 964                                      struct sys_notify_context *ctx,
 965                                      struct notify_entry *e,
 966                                      void (*callback)(struct sys_notify_context *ctx,
 967                                                       void *private_data,
 968                                                       struct notify_event *ev),
 969                                      void *private_data, void *handle)
 970 {
 971         /*
 972          * So far inotify is the only supported default notify mechanism. If
 973          * another platform like the the BSD's or a proprietary Unix comes
 974          * along and wants another default, we can play the same trick we
 975          * played with Posix ACLs.
 976          *
 977          * Until that is the case, hard-code inotify here.
 978          */
 979 #ifdef HAVE_INOTIFY
 980         if (lp_kernel_change_notify(ctx->conn->params)) {
 981                 return inotify_watch(ctx, e, callback, private_data, handle);
 982         }
 983 #endif
 984         /*
 985          * Do nothing, leave everything to notify_internal.c
 986          */
 987         return NT_STATUS_OK;
 988 }
 989
 990 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
 991 {
 992 #ifdef HAVE_CHFLAGS
 993         return chflags(path, flags);
 994 #else
 995         errno = ENOSYS;
 996         return -1;
 997 #endif
 998 }
 999
1000 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
1001 {
1002         return file_id_create_dev(dev, inode);
1003 }
1004
1005 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1006                                    struct files_struct *fsp,
1007                                    const char *fname,
1008                                    TALLOC_CTX *mem_ctx,
1009                                    unsigned int *pnum_streams,
1010                                    struct stream_struct **pstreams)
1011 {
1012         SMB_STRUCT_STAT sbuf;
1013         unsigned int num_streams = 0;
1014         struct stream_struct *streams = NULL;
1015         int ret;
1016
1017         if ((fsp != NULL) && (fsp->is_directory)) {
1018                 /*
1019                  * No default streams on directories
1020                  */
1021                 goto done;
1022         }
1023
1024         if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1025                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1026         }
1027         else {
1028                 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
1029         }
1030
1031         if (ret == -1) {
1032                 return map_nt_error_from_unix(errno);
1033         }
1034
1035         if (S_ISDIR(sbuf.st_mode)) {
1036                 goto done;
1037         }
1038
1039         streams = talloc(mem_ctx, struct stream_struct);
1040
1041         if (streams == NULL) {
1042                 return NT_STATUS_NO_MEMORY;
1043         }
1044
1045         streams->size = sbuf.st_size;
1046         streams->alloc_size = get_allocation_size(handle->conn, fsp, &sbuf);
1047
1048         streams->name = talloc_strdup(streams, "::$DATA");
1049         if (streams->name == NULL) {
1050                 TALLOC_FREE(streams);
1051                 return NT_STATUS_NO_MEMORY;
1052         }
1053
1054         num_streams = 1;
1055  done:
1056         *pnum_streams = num_streams;
1057         *pstreams = streams;
1058         return NT_STATUS_OK;
1059 }
1060
1061 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1062                                      const char *path,
1063                                      const char *name,
1064                                      TALLOC_CTX *mem_ctx,
1065                                      char **found_name)
1066 {
1067         return get_real_filename(handle->conn, path, name, mem_ctx,
1068                                  found_name);
1069 }
1070
1071 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1072                                     files_struct *fsp,
1073                                     uint32 security_info, SEC_DESC **ppdesc)
1074 {
1075         NTSTATUS result;
1076
1077         START_PROFILE(fget_nt_acl);
1078         result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1079         END_PROFILE(fget_nt_acl);
1080         return result;
1081 }
1082
1083 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1084                                    const char *name,
1085                                    uint32 security_info, SEC_DESC **ppdesc)
1086 {
1087         NTSTATUS result;
1088
1089         START_PROFILE(get_nt_acl);
1090         result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1091         END_PROFILE(get_nt_acl);
1092         return result;
1093 }
1094
1095 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1096 {
1097         NTSTATUS result;
1098
1099         START_PROFILE(fset_nt_acl);
1100         result = set_nt_acl(fsp, security_info_sent, psd);
1101         END_PROFILE(fset_nt_acl);
1102         return result;
1103 }
1104
1105 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
1106 {
1107 #ifdef HAVE_NO_ACL
1108         errno = ENOSYS;
1109         return -1;
1110 #else
1111         int result;
1112
1113         START_PROFILE(chmod_acl);
1114         result = chmod_acl(handle->conn, name, mode);
1115         END_PROFILE(chmod_acl);
1116         return result;
1117 #endif
1118 }
1119
1120 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1121 {
1122 #ifdef HAVE_NO_ACL
1123         errno = ENOSYS;
1124         return -1;
1125 #else
1126         int result;
1127
1128         START_PROFILE(fchmod_acl);
1129         result = fchmod_acl(fsp, mode);
1130         END_PROFILE(fchmod_acl);
1131         return result;
1132 #endif
1133 }
1134
1135 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1136 {
1137         return sys_acl_get_entry(theacl, entry_id, entry_p);
1138 }
1139
1140 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)
1141 {
1142         return sys_acl_get_tag_type(entry_d, tag_type_p);
1143 }
1144
1145 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1146 {
1147         return sys_acl_get_permset(entry_d, permset_p);
1148 }
1149
1150 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
1151 {
1152         return sys_acl_get_qualifier(entry_d);
1153 }
1154
1155 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
1156 {
1157         return sys_acl_get_file(handle, path_p, type);
1158 }
1159
1160 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1161 {
1162         return sys_acl_get_fd(handle, fsp);
1163 }
1164
1165 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
1166 {
1167         return sys_acl_clear_perms(permset);
1168 }
1169
1170 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1171 {
1172         return sys_acl_add_perm(permset, perm);
1173 }
1174
1175 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
1176 {
1177         return sys_acl_to_text(theacl, plen);
1178 }
1179
1180 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle,  int count)
1181 {
1182         return sys_acl_init(count);
1183 }
1184
1185 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1186 {
1187         return sys_acl_create_entry(pacl, pentry);
1188 }
1189
1190 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1191 {
1192         return sys_acl_set_tag_type(entry, tagtype);
1193 }
1194
1195 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
1196 {
1197         return sys_acl_set_qualifier(entry, qual);
1198 }
1199
1200 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1201 {
1202         return sys_acl_set_permset(entry, permset);
1203 }
1204
1205 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
1206 {
1207         return sys_acl_valid(theacl );
1208 }
1209
1210 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1211 {
1212         return sys_acl_set_file(handle, name, acltype, theacl);
1213 }
1214
1215 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1216 {
1217         return sys_acl_set_fd(handle, fsp, theacl);
1218 }
1219
1220 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
1221 {
1222         return sys_acl_delete_def_file(handle, path);
1223 }
1224
1225 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1226 {
1227         return sys_acl_get_perm(permset, perm);
1228 }
1229
1230 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
1231 {
1232         return sys_acl_free_text(text);
1233 }
1234
1235 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
1236 {
1237         return sys_acl_free_acl(posix_acl);
1238 }
1239
1240 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
1241 {
1242         return sys_acl_free_qualifier(qualifier, tagtype);
1243 }
1244
1245 /****************************************************************
1246  Extended attribute operations.
1247 *****************************************************************/
1248
1249 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1250 {
1251         return sys_getxattr(path, name, value, size);
1252 }
1253
1254 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1255 {
1256         return sys_lgetxattr(path, name, value, size);
1257 }
1258
1259 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1260 {
1261         return sys_fgetxattr(fsp->fh->fd, name, value, size);
1262 }
1263
1264 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1265 {
1266         return sys_listxattr(path, list, size);
1267 }
1268
1269 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1270 {
1271         return sys_llistxattr(path, list, size);
1272 }
1273
1274 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1275 {
1276         return sys_flistxattr(fsp->fh->fd, list, size);
1277 }
1278
1279 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1280 {
1281         return sys_removexattr(path, name);
1282 }
1283
1284 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1285 {
1286         return sys_lremovexattr(path, name);
1287 }
1288
1289 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1290 {
1291         return sys_fremovexattr(fsp->fh->fd, name);
1292 }
1293
1294 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1295 {
1296         return sys_setxattr(path, name, value, size, flags);
1297 }
1298
1299 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1300 {
1301         return sys_lsetxattr(path, name, value, size, flags);
1302 }
1303
1304 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1305 {
1306         return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1307 }
1308
1309 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1310 {
1311         return sys_aio_read(aiocb);
1312 }
1313
1314 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1315 {
1316         return sys_aio_write(aiocb);
1317 }
1318
1319 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1320 {
1321         return sys_aio_return(aiocb);
1322 }
1323
1324 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1325 {
1326         return sys_aio_cancel(fsp->fh->fd, aiocb);
1327 }
1328
1329 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1330 {
1331         return sys_aio_error(aiocb);
1332 }
1333
1334 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1335 {
1336         return sys_aio_fsync(op, aiocb);
1337 }
1338
1339 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)
1340 {
1341         return sys_aio_suspend(aiocb, n, timeout);
1342 }
1343
1344 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1345 {
1346         return false;
1347 }
1348
1349 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1350 {
1351         if (ISDOT(path) || ISDOTDOT(path)) {
1352                 return false;
1353         }
1354
1355         if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1356 #if defined(ENOTSUP)
1357                 errno = ENOTSUP;
1358 #endif
1359                 return false;
1360         }
1361
1362         return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1363 }
1364
1365 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1366 {
1367         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1368 #if defined(ENOTSUP)
1369         errno = ENOTSUP;
1370 #endif
1371         return -1;
1372 }
1373
1374 static vfs_op_tuple vfs_default_ops[] = {
1375
1376         /* Disk operations */
1377
1378         {SMB_VFS_OP(vfswrap_connect),   SMB_VFS_OP_CONNECT,
1379          SMB_VFS_LAYER_OPAQUE},
1380         {SMB_VFS_OP(vfswrap_disconnect),        SMB_VFS_OP_DISCONNECT,
1381          SMB_VFS_LAYER_OPAQUE},
1382         {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1383          SMB_VFS_LAYER_OPAQUE},
1384         {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1385          SMB_VFS_LAYER_OPAQUE},
1386         {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1387          SMB_VFS_LAYER_OPAQUE},
1388         {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1389          SMB_VFS_LAYER_OPAQUE},
1390         {SMB_VFS_OP(vfswrap_statvfs),   SMB_VFS_OP_STATVFS,
1391          SMB_VFS_LAYER_OPAQUE},
1392         {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1393          SMB_VFS_LAYER_OPAQUE},
1394
1395         /* Directory operations */
1396
1397         {SMB_VFS_OP(vfswrap_opendir),   SMB_VFS_OP_OPENDIR,
1398          SMB_VFS_LAYER_OPAQUE},
1399         {SMB_VFS_OP(vfswrap_readdir),   SMB_VFS_OP_READDIR,
1400          SMB_VFS_LAYER_OPAQUE},
1401         {SMB_VFS_OP(vfswrap_seekdir),   SMB_VFS_OP_SEEKDIR,
1402          SMB_VFS_LAYER_OPAQUE},
1403         {SMB_VFS_OP(vfswrap_telldir),   SMB_VFS_OP_TELLDIR,
1404          SMB_VFS_LAYER_OPAQUE},
1405         {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1406          SMB_VFS_LAYER_OPAQUE},
1407         {SMB_VFS_OP(vfswrap_mkdir),     SMB_VFS_OP_MKDIR,
1408          SMB_VFS_LAYER_OPAQUE},
1409         {SMB_VFS_OP(vfswrap_rmdir),     SMB_VFS_OP_RMDIR,
1410          SMB_VFS_LAYER_OPAQUE},
1411         {SMB_VFS_OP(vfswrap_closedir),  SMB_VFS_OP_CLOSEDIR,
1412          SMB_VFS_LAYER_OPAQUE},
1413
1414         /* File operations */
1415
1416         {SMB_VFS_OP(vfswrap_open),      SMB_VFS_OP_OPEN,
1417          SMB_VFS_LAYER_OPAQUE},
1418         {SMB_VFS_OP(vfswrap_create_file),       SMB_VFS_OP_CREATE_FILE,
1419          SMB_VFS_LAYER_OPAQUE},
1420         {SMB_VFS_OP(vfswrap_close),     SMB_VFS_OP_CLOSE,
1421          SMB_VFS_LAYER_OPAQUE},
1422         {SMB_VFS_OP(vfswrap_read),      SMB_VFS_OP_READ,
1423          SMB_VFS_LAYER_OPAQUE},
1424         {SMB_VFS_OP(vfswrap_pread),     SMB_VFS_OP_PREAD,
1425          SMB_VFS_LAYER_OPAQUE},
1426         {SMB_VFS_OP(vfswrap_write),     SMB_VFS_OP_WRITE,
1427          SMB_VFS_LAYER_OPAQUE},
1428         {SMB_VFS_OP(vfswrap_pwrite),    SMB_VFS_OP_PWRITE,
1429          SMB_VFS_LAYER_OPAQUE},
1430         {SMB_VFS_OP(vfswrap_lseek),     SMB_VFS_OP_LSEEK,
1431          SMB_VFS_LAYER_OPAQUE},
1432         {SMB_VFS_OP(vfswrap_sendfile),  SMB_VFS_OP_SENDFILE,
1433          SMB_VFS_LAYER_OPAQUE},
1434         {SMB_VFS_OP(vfswrap_recvfile),  SMB_VFS_OP_RECVFILE,
1435          SMB_VFS_LAYER_OPAQUE},
1436         {SMB_VFS_OP(vfswrap_rename),    SMB_VFS_OP_RENAME,
1437          SMB_VFS_LAYER_OPAQUE},
1438         {SMB_VFS_OP(vfswrap_fsync),     SMB_VFS_OP_FSYNC,
1439          SMB_VFS_LAYER_OPAQUE},
1440         {SMB_VFS_OP(vfswrap_stat),      SMB_VFS_OP_STAT,
1441          SMB_VFS_LAYER_OPAQUE},
1442         {SMB_VFS_OP(vfswrap_fstat),     SMB_VFS_OP_FSTAT,
1443          SMB_VFS_LAYER_OPAQUE},
1444         {SMB_VFS_OP(vfswrap_lstat),     SMB_VFS_OP_LSTAT,
1445          SMB_VFS_LAYER_OPAQUE},
1446         {SMB_VFS_OP(vfswrap_unlink),    SMB_VFS_OP_UNLINK,
1447          SMB_VFS_LAYER_OPAQUE},
1448         {SMB_VFS_OP(vfswrap_chmod),     SMB_VFS_OP_CHMOD,
1449          SMB_VFS_LAYER_OPAQUE},
1450         {SMB_VFS_OP(vfswrap_fchmod),    SMB_VFS_OP_FCHMOD,
1451          SMB_VFS_LAYER_OPAQUE},
1452         {SMB_VFS_OP(vfswrap_chown),     SMB_VFS_OP_CHOWN,
1453          SMB_VFS_LAYER_OPAQUE},
1454         {SMB_VFS_OP(vfswrap_fchown),    SMB_VFS_OP_FCHOWN,
1455          SMB_VFS_LAYER_OPAQUE},
1456         {SMB_VFS_OP(vfswrap_lchown),    SMB_VFS_OP_LCHOWN,
1457          SMB_VFS_LAYER_OPAQUE},
1458         {SMB_VFS_OP(vfswrap_chdir),     SMB_VFS_OP_CHDIR,
1459          SMB_VFS_LAYER_OPAQUE},
1460         {SMB_VFS_OP(vfswrap_getwd),     SMB_VFS_OP_GETWD,
1461          SMB_VFS_LAYER_OPAQUE},
1462         {SMB_VFS_OP(vfswrap_ntimes),    SMB_VFS_OP_NTIMES,
1463          SMB_VFS_LAYER_OPAQUE},
1464         {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1465          SMB_VFS_LAYER_OPAQUE},
1466         {SMB_VFS_OP(vfswrap_lock),      SMB_VFS_OP_LOCK,
1467          SMB_VFS_LAYER_OPAQUE},
1468         {SMB_VFS_OP(vfswrap_kernel_flock),      SMB_VFS_OP_KERNEL_FLOCK,
1469          SMB_VFS_LAYER_OPAQUE},
1470         {SMB_VFS_OP(vfswrap_linux_setlease),    SMB_VFS_OP_LINUX_SETLEASE,
1471          SMB_VFS_LAYER_OPAQUE},
1472         {SMB_VFS_OP(vfswrap_getlock),   SMB_VFS_OP_GETLOCK,
1473          SMB_VFS_LAYER_OPAQUE},
1474         {SMB_VFS_OP(vfswrap_symlink),   SMB_VFS_OP_SYMLINK,
1475          SMB_VFS_LAYER_OPAQUE},
1476         {SMB_VFS_OP(vfswrap_readlink),  SMB_VFS_OP_READLINK,
1477          SMB_VFS_LAYER_OPAQUE},
1478         {SMB_VFS_OP(vfswrap_link),      SMB_VFS_OP_LINK,
1479          SMB_VFS_LAYER_OPAQUE},
1480         {SMB_VFS_OP(vfswrap_mknod),     SMB_VFS_OP_MKNOD,
1481          SMB_VFS_LAYER_OPAQUE},
1482         {SMB_VFS_OP(vfswrap_realpath),  SMB_VFS_OP_REALPATH,
1483          SMB_VFS_LAYER_OPAQUE},
1484         {SMB_VFS_OP(vfswrap_notify_watch),      SMB_VFS_OP_NOTIFY_WATCH,
1485          SMB_VFS_LAYER_OPAQUE},
1486         {SMB_VFS_OP(vfswrap_chflags),   SMB_VFS_OP_CHFLAGS,
1487          SMB_VFS_LAYER_OPAQUE},
1488         {SMB_VFS_OP(vfswrap_file_id_create),    SMB_VFS_OP_FILE_ID_CREATE,
1489          SMB_VFS_LAYER_OPAQUE},
1490         {SMB_VFS_OP(vfswrap_streaminfo),        SMB_VFS_OP_STREAMINFO,
1491          SMB_VFS_LAYER_OPAQUE},
1492         {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1493          SMB_VFS_LAYER_OPAQUE},
1494
1495         /* NT ACL operations. */
1496
1497         {SMB_VFS_OP(vfswrap_fget_nt_acl),       SMB_VFS_OP_FGET_NT_ACL,
1498          SMB_VFS_LAYER_OPAQUE},
1499         {SMB_VFS_OP(vfswrap_get_nt_acl),        SMB_VFS_OP_GET_NT_ACL,
1500          SMB_VFS_LAYER_OPAQUE},
1501         {SMB_VFS_OP(vfswrap_fset_nt_acl),       SMB_VFS_OP_FSET_NT_ACL,
1502          SMB_VFS_LAYER_OPAQUE},
1503
1504         /* POSIX ACL operations. */
1505
1506         {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1507          SMB_VFS_LAYER_OPAQUE},
1508         {SMB_VFS_OP(vfswrap_fchmod_acl),        SMB_VFS_OP_FCHMOD_ACL,
1509          SMB_VFS_LAYER_OPAQUE},
1510         {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1511          SMB_VFS_LAYER_OPAQUE},
1512         {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type),      SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1513          SMB_VFS_LAYER_OPAQUE},
1514         {SMB_VFS_OP(vfswrap_sys_acl_get_permset),       SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1515          SMB_VFS_LAYER_OPAQUE},
1516         {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier),     SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1517          SMB_VFS_LAYER_OPAQUE},
1518         {SMB_VFS_OP(vfswrap_sys_acl_get_file),  SMB_VFS_OP_SYS_ACL_GET_FILE,
1519          SMB_VFS_LAYER_OPAQUE},
1520         {SMB_VFS_OP(vfswrap_sys_acl_get_fd),    SMB_VFS_OP_SYS_ACL_GET_FD,
1521          SMB_VFS_LAYER_OPAQUE},
1522         {SMB_VFS_OP(vfswrap_sys_acl_clear_perms),       SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1523          SMB_VFS_LAYER_OPAQUE},
1524         {SMB_VFS_OP(vfswrap_sys_acl_add_perm),  SMB_VFS_OP_SYS_ACL_ADD_PERM,
1525          SMB_VFS_LAYER_OPAQUE},
1526         {SMB_VFS_OP(vfswrap_sys_acl_to_text),   SMB_VFS_OP_SYS_ACL_TO_TEXT,
1527          SMB_VFS_LAYER_OPAQUE},
1528         {SMB_VFS_OP(vfswrap_sys_acl_init),      SMB_VFS_OP_SYS_ACL_INIT,
1529          SMB_VFS_LAYER_OPAQUE},
1530         {SMB_VFS_OP(vfswrap_sys_acl_create_entry),      SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1531          SMB_VFS_LAYER_OPAQUE},
1532         {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type),      SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1533          SMB_VFS_LAYER_OPAQUE},
1534         {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier),     SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1535          SMB_VFS_LAYER_OPAQUE},
1536         {SMB_VFS_OP(vfswrap_sys_acl_set_permset),       SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1537          SMB_VFS_LAYER_OPAQUE},
1538         {SMB_VFS_OP(vfswrap_sys_acl_valid),     SMB_VFS_OP_SYS_ACL_VALID,
1539          SMB_VFS_LAYER_OPAQUE},
1540         {SMB_VFS_OP(vfswrap_sys_acl_set_file),  SMB_VFS_OP_SYS_ACL_SET_FILE,
1541          SMB_VFS_LAYER_OPAQUE},
1542         {SMB_VFS_OP(vfswrap_sys_acl_set_fd),    SMB_VFS_OP_SYS_ACL_SET_FD,
1543          SMB_VFS_LAYER_OPAQUE},
1544         {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file),   SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1545          SMB_VFS_LAYER_OPAQUE},
1546         {SMB_VFS_OP(vfswrap_sys_acl_get_perm),  SMB_VFS_OP_SYS_ACL_GET_PERM,
1547          SMB_VFS_LAYER_OPAQUE},
1548         {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1549          SMB_VFS_LAYER_OPAQUE},
1550         {SMB_VFS_OP(vfswrap_sys_acl_free_acl),  SMB_VFS_OP_SYS_ACL_FREE_ACL,
1551          SMB_VFS_LAYER_OPAQUE},
1552         {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier),    SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1553          SMB_VFS_LAYER_OPAQUE},
1554
1555         /* EA operations. */
1556
1557         {SMB_VFS_OP(vfswrap_getxattr),  SMB_VFS_OP_GETXATTR,
1558          SMB_VFS_LAYER_OPAQUE},
1559         {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1560          SMB_VFS_LAYER_OPAQUE},
1561         {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1562          SMB_VFS_LAYER_OPAQUE},
1563         {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1564          SMB_VFS_LAYER_OPAQUE},
1565         {SMB_VFS_OP(vfswrap_llistxattr),        SMB_VFS_OP_LLISTXATTR,
1566          SMB_VFS_LAYER_OPAQUE},
1567         {SMB_VFS_OP(vfswrap_flistxattr),        SMB_VFS_OP_FLISTXATTR,
1568          SMB_VFS_LAYER_OPAQUE},
1569         {SMB_VFS_OP(vfswrap_removexattr),       SMB_VFS_OP_REMOVEXATTR,
1570          SMB_VFS_LAYER_OPAQUE},
1571         {SMB_VFS_OP(vfswrap_lremovexattr),      SMB_VFS_OP_LREMOVEXATTR,
1572          SMB_VFS_LAYER_OPAQUE},
1573         {SMB_VFS_OP(vfswrap_fremovexattr),      SMB_VFS_OP_FREMOVEXATTR,
1574          SMB_VFS_LAYER_OPAQUE},
1575         {SMB_VFS_OP(vfswrap_setxattr),  SMB_VFS_OP_SETXATTR,
1576          SMB_VFS_LAYER_OPAQUE},
1577         {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1578          SMB_VFS_LAYER_OPAQUE},
1579         {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1580          SMB_VFS_LAYER_OPAQUE},
1581
1582         {SMB_VFS_OP(vfswrap_aio_read),  SMB_VFS_OP_AIO_READ,
1583          SMB_VFS_LAYER_OPAQUE},
1584         {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1585          SMB_VFS_LAYER_OPAQUE},
1586         {SMB_VFS_OP(vfswrap_aio_return),        SMB_VFS_OP_AIO_RETURN,
1587          SMB_VFS_LAYER_OPAQUE},
1588         {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1589          SMB_VFS_LAYER_OPAQUE},
1590         {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1591          SMB_VFS_LAYER_OPAQUE},
1592         {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1593          SMB_VFS_LAYER_OPAQUE},
1594         {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1595          SMB_VFS_LAYER_OPAQUE},
1596
1597         {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1598          SMB_VFS_LAYER_OPAQUE},
1599
1600         {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1601          SMB_VFS_LAYER_OPAQUE},
1602         {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1603          SMB_VFS_LAYER_OPAQUE},
1604
1605         /* Finish VFS operations definition */
1606
1607         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,
1608          SMB_VFS_LAYER_NOOP}
1609 };
1610
1611 NTSTATUS vfs_default_init(void);
1612 NTSTATUS vfs_default_init(void)
1613 {
1614         unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1615
1616         if (ARRAY_SIZE(vfs_default_ops) != needed) {
1617                 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1618                         DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1619                 smb_panic("operation(s) missing from default VFS module");
1620         }
1621
1622         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1623                                 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);
1624 }