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