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