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 #include "system/time.h"
  23 #include "system/filesys.h"
  24 #include "smbd/smbd.h"
  25 #include "ntioctl.h"
  26 #include "smbprofile.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_VFS
  30
  31 /* Check for NULL pointer parameters in vfswrap_* functions */
  32
  33 /* We don't want to have NULL function pointers lying around.  Someone
  34    is sure to try and execute them.  These stubs are used to prevent
  35    this possibility. */
  36
  37 static int vfswrap_connect(vfs_handle_struct *handle,  const char *service, const char *user)
  38 {
  39     return 0;    /* Return >= 0 for success */
  40 }
  41
  42 static void vfswrap_disconnect(vfs_handle_struct *handle)
  43 {
  44 }
  45
  46 /* Disk operations */
  47
  48 static uint64_t vfswrap_disk_free(vfs_handle_struct *handle,  const char *path, bool small_query, uint64_t *bsize,
  49                                uint64_t *dfree, uint64_t *dsize)
  50 {
  51         uint64_t result;
  52
  53         result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
  54         return result;
  55 }
  56
  57 static int vfswrap_get_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  58 {
  59 #ifdef HAVE_SYS_QUOTAS
  60         int result;
  61
  62         START_PROFILE(syscall_get_quota);
  63         result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
  64         END_PROFILE(syscall_get_quota);
  65         return result;
  66 #else
  67         errno = ENOSYS;
  68         return -1;
  69 #endif
  70 }
  71
  72 static int vfswrap_set_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  73 {
  74 #ifdef HAVE_SYS_QUOTAS
  75         int result;
  76
  77         START_PROFILE(syscall_set_quota);
  78         result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
  79         END_PROFILE(syscall_set_quota);
  80         return result;
  81 #else
  82         errno = ENOSYS;
  83         return -1;
  84 #endif
  85 }
  86
  87 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
  88                                         struct files_struct *fsp,
  89                                         struct shadow_copy_data *shadow_copy_data,
  90                                         bool labels)
  91 {
  92         errno = ENOSYS;
  93         return -1;  /* Not implemented. */
  94 }
  95
  96 static int vfswrap_statvfs(struct vfs_handle_struct *handle,  const char *path, vfs_statvfs_struct *statbuf)
  97 {
  98         return sys_statvfs(path, statbuf);
  99 }
 100
 101 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
 102                 enum timestamp_set_resolution *p_ts_res)
 103 {
 104         connection_struct *conn = handle->conn;
 105         uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
 106         struct smb_filename *smb_fname_cpath = NULL;
 107         NTSTATUS status;
 108         int ret = -1;
 109
 110 #if defined(DARWINOS)
 111         struct vfs_statvfs_struct statbuf;
 112         ZERO_STRUCT(statbuf);
 113         sys_statvfs(conn->connectpath, &statbuf);
 114         caps = statbuf.FsCapabilities;
 115 #endif
 116
 117         *p_ts_res = TIMESTAMP_SET_SECONDS;
 118
 119         /* Work out what timestamp resolution we can
 120          * use when setting a timestamp. */
 121
 122         status = create_synthetic_smb_fname(talloc_tos(),
 123                                 conn->connectpath,
 124                                 NULL,
 125                                 NULL,
 126                                 &smb_fname_cpath);
 127         if (!NT_STATUS_IS_OK(status)) {
 128                 return caps;
 129         }
 130
 131         ret = SMB_VFS_STAT(conn, smb_fname_cpath);
 132         if (ret == -1) {
 133                 TALLOC_FREE(smb_fname_cpath);
 134                 return caps;
 135         }
 136
 137         if (smb_fname_cpath->st.st_ex_mtime.tv_nsec ||
 138                         smb_fname_cpath->st.st_ex_atime.tv_nsec ||
 139                         smb_fname_cpath->st.st_ex_ctime.tv_nsec) {
 140                 /* If any of the normal UNIX directory timestamps
 141                  * have a non-zero tv_nsec component assume
 142                  * we might be able to set sub-second timestamps.
 143                  * See what filetime set primitives we have.
 144                  */
 145 #if defined(HAVE_UTIMENSAT)
 146                 *p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
 147 #elif defined(HAVE_UTIMES)
 148                 /* utimes allows msec timestamps to be set. */
 149                 *p_ts_res = TIMESTAMP_SET_MSEC;
 150 #elif defined(HAVE_UTIME)
 151                 /* utime only allows sec timestamps to be set. */
 152                 *p_ts_res = TIMESTAMP_SET_SECONDS;
 153 #endif
 154
 155                 DEBUG(10,("vfswrap_fs_capabilities: timestamp "
 156                         "resolution of %s "
 157                         "available on share %s, directory %s\n",
 158                         *p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
 159                         lp_servicename(conn->params->service),
 160                         conn->connectpath ));
 161         }
 162         TALLOC_FREE(smb_fname_cpath);
 163         return caps;
 164 }
 165
 166 /* Directory operations */
 167
 168 static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
 169 {
 170         SMB_STRUCT_DIR *result;
 171
 172         START_PROFILE(syscall_opendir);
 173         result = sys_opendir(fname);
 174         END_PROFILE(syscall_opendir);
 175         return result;
 176 }
 177
 178 static SMB_STRUCT_DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
 179                         files_struct *fsp,
 180                         const char *mask,
 181                         uint32 attr)
 182 {
 183         SMB_STRUCT_DIR *result;
 184
 185         START_PROFILE(syscall_fdopendir);
 186         result = sys_fdopendir(fsp->fh->fd);
 187         END_PROFILE(syscall_fdopendir);
 188         return result;
 189 }
 190
 191
 192 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle,
 193                                           SMB_STRUCT_DIR *dirp,
 194                                           SMB_STRUCT_STAT *sbuf)
 195 {
 196         SMB_STRUCT_DIRENT *result;
 197
 198         START_PROFILE(syscall_readdir);
 199         result = sys_readdir(dirp);
 200         /* Default Posix readdir() does not give us stat info.
 201          * Set to invalid to indicate we didn't return this info. */
 202         if (sbuf)
 203                 SET_STAT_INVALID(*sbuf);
 204         END_PROFILE(syscall_readdir);
 205         return result;
 206 }
 207
 208 static void vfswrap_seekdir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp, long offset)
 209 {
 210         START_PROFILE(syscall_seekdir);
 211         sys_seekdir(dirp, offset);
 212         END_PROFILE(syscall_seekdir);
 213 }
 214
 215 static long vfswrap_telldir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 216 {
 217         long result;
 218         START_PROFILE(syscall_telldir);
 219         result = sys_telldir(dirp);
 220         END_PROFILE(syscall_telldir);
 221         return result;
 222 }
 223
 224 static void vfswrap_rewinddir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 225 {
 226         START_PROFILE(syscall_rewinddir);
 227         sys_rewinddir(dirp);
 228         END_PROFILE(syscall_rewinddir);
 229 }
 230
 231 static int vfswrap_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
 232 {
 233         int result;
 234         bool has_dacl = False;
 235         char *parent = NULL;
 236
 237         START_PROFILE(syscall_mkdir);
 238
 239         if (lp_inherit_acls(SNUM(handle->conn))
 240             && parent_dirname(talloc_tos(), path, &parent, NULL)
 241             && (has_dacl = directory_has_default_acl(handle->conn, parent)))
 242                 mode = (0777 & lp_dir_mask(SNUM(handle->conn)));
 243
 244         TALLOC_FREE(parent);
 245
 246         result = mkdir(path, mode);
 247
 248         if (result == 0 && !has_dacl) {
 249                 /*
 250                  * We need to do this as the default behavior of POSIX ACLs
 251                  * is to set the mask to be the requested group permission
 252                  * bits, not the group permission bits to be the requested
 253                  * group permission bits. This is not what we want, as it will
 254                  * mess up any inherited ACL bits that were set. JRA.
 255                  */
 256                 int saved_errno = errno; /* We may get ENOSYS */
 257                 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
 258                         errno = saved_errno;
 259         }
 260
 261         END_PROFILE(syscall_mkdir);
 262         return result;
 263 }
 264
 265 static int vfswrap_rmdir(vfs_handle_struct *handle,  const char *path)
 266 {
 267         int result;
 268
 269         START_PROFILE(syscall_rmdir);
 270         result = rmdir(path);
 271         END_PROFILE(syscall_rmdir);
 272         return result;
 273 }
 274
 275 static int vfswrap_closedir(vfs_handle_struct *handle,  SMB_STRUCT_DIR *dirp)
 276 {
 277         int result;
 278
 279         START_PROFILE(syscall_closedir);
 280         result = sys_closedir(dirp);
 281         END_PROFILE(syscall_closedir);
 282         return result;
 283 }
 284
 285 static void vfswrap_init_search_op(vfs_handle_struct *handle,
 286                                    SMB_STRUCT_DIR *dirp)
 287 {
 288         /* Default behavior is a NOOP */
 289 }
 290
 291 /* File operations */
 292
 293 static int vfswrap_open(vfs_handle_struct *handle,
 294                         struct smb_filename *smb_fname,
 295                         files_struct *fsp, int flags, mode_t mode)
 296 {
 297         int result = -1;
 298
 299         START_PROFILE(syscall_open);
 300
 301         if (smb_fname->stream_name) {
 302                 errno = ENOENT;
 303                 goto out;
 304         }
 305
 306         result = sys_open(smb_fname->base_name, flags, mode);
 307  out:
 308         END_PROFILE(syscall_open);
 309         return result;
 310 }
 311
 312 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
 313                                     struct smb_request *req,
 314                                     uint16_t root_dir_fid,
 315                                     struct smb_filename *smb_fname,
 316                                     uint32_t access_mask,
 317                                     uint32_t share_access,
 318                                     uint32_t create_disposition,
 319                                     uint32_t create_options,
 320                                     uint32_t file_attributes,
 321                                     uint32_t oplock_request,
 322                                     uint64_t allocation_size,
 323                                     uint32_t private_flags,
 324                                     struct security_descriptor *sd,
 325                                     struct ea_list *ea_list,
 326                                     files_struct **result,
 327                                     int *pinfo)
 328 {
 329         return create_file_default(handle->conn, req, root_dir_fid, smb_fname,
 330                                    access_mask, share_access,
 331                                    create_disposition, create_options,
 332                                    file_attributes, oplock_request,
 333                                    allocation_size, private_flags,
 334                                    sd, ea_list, result,
 335                                    pinfo);
 336 }
 337
 338 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
 339 {
 340         int result;
 341
 342         START_PROFILE(syscall_close);
 343         result = fd_close_posix(fsp);
 344         END_PROFILE(syscall_close);
 345         return result;
 346 }
 347
 348 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
 349 {
 350         ssize_t result;
 351
 352         START_PROFILE_BYTES(syscall_read, n);
 353         result = sys_read(fsp->fh->fd, data, n);
 354         END_PROFILE(syscall_read);
 355         return result;
 356 }
 357
 358 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
 359                         size_t n, SMB_OFF_T offset)
 360 {
 361         ssize_t result;
 362
 363 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 364         START_PROFILE_BYTES(syscall_pread, n);
 365         result = sys_pread(fsp->fh->fd, data, n, offset);
 366         END_PROFILE(syscall_pread);
 367
 368         if (result == -1 && errno == ESPIPE) {
 369                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 370                 result = SMB_VFS_READ(fsp, data, n);
 371                 fsp->fh->pos = 0;
 372         }
 373
 374 #else /* HAVE_PREAD */
 375         SMB_OFF_T   curr;
 376         int lerrno;
 377
 378         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 379         if (curr == -1 && errno == ESPIPE) {
 380                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 381                 result = SMB_VFS_READ(fsp, data, n);
 382                 fsp->fh->pos = 0;
 383                 return result;
 384         }
 385
 386         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 387                 return -1;
 388         }
 389
 390         errno = 0;
 391         result = SMB_VFS_READ(fsp, data, n);
 392         lerrno = errno;
 393
 394         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 395         errno = lerrno;
 396
 397 #endif /* HAVE_PREAD */
 398
 399         return result;
 400 }
 401
 402 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 403 {
 404         ssize_t result;
 405
 406         START_PROFILE_BYTES(syscall_write, n);
 407         result = sys_write(fsp->fh->fd, data, n);
 408         END_PROFILE(syscall_write);
 409         return result;
 410 }
 411
 412 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
 413                         size_t n, SMB_OFF_T offset)
 414 {
 415         ssize_t result;
 416
 417 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 418         START_PROFILE_BYTES(syscall_pwrite, n);
 419         result = sys_pwrite(fsp->fh->fd, data, n, offset);
 420         END_PROFILE(syscall_pwrite);
 421
 422         if (result == -1 && errno == ESPIPE) {
 423                 /* Maintain the fiction that pipes can be sought on. */
 424                 result = SMB_VFS_WRITE(fsp, data, n);
 425         }
 426
 427 #else /* HAVE_PWRITE */
 428         SMB_OFF_T   curr;
 429         int         lerrno;
 430
 431         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 432         if (curr == -1) {
 433                 return -1;
 434         }
 435
 436         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 437                 return -1;
 438         }
 439
 440         result = SMB_VFS_WRITE(fsp, data, n);
 441         lerrno = errno;
 442
 443         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 444         errno = lerrno;
 445
 446 #endif /* HAVE_PWRITE */
 447
 448         return result;
 449 }
 450
 451 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
 452 {
 453         SMB_OFF_T result = 0;
 454
 455         START_PROFILE(syscall_lseek);
 456
 457         /* Cope with 'stat' file opens. */
 458         if (fsp->fh->fd != -1)
 459                 result = sys_lseek(fsp->fh->fd, offset, whence);
 460
 461         /*
 462          * We want to maintain the fiction that we can seek
 463          * on a fifo for file system purposes. This allows
 464          * people to set up UNIX fifo's that feed data to Windows
 465          * applications. JRA.
 466          */
 467
 468         if((result == -1) && (errno == ESPIPE)) {
 469                 result = 0;
 470                 errno = 0;
 471         }
 472
 473         END_PROFILE(syscall_lseek);
 474         return result;
 475 }
 476
 477 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
 478                         SMB_OFF_T offset, size_t n)
 479 {
 480         ssize_t result;
 481
 482         START_PROFILE_BYTES(syscall_sendfile, n);
 483         result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
 484         END_PROFILE(syscall_sendfile);
 485         return result;
 486 }
 487
 488 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
 489                         int fromfd,
 490                         files_struct *tofsp,
 491                         SMB_OFF_T offset,
 492                         size_t n)
 493 {
 494         ssize_t result;
 495
 496         START_PROFILE_BYTES(syscall_recvfile, n);
 497         result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
 498         END_PROFILE(syscall_recvfile);
 499         return result;
 500 }
 501
 502 static int vfswrap_rename(vfs_handle_struct *handle,
 503                           const struct smb_filename *smb_fname_src,
 504                           const struct smb_filename *smb_fname_dst)
 505 {
 506         int result = -1;
 507
 508         START_PROFILE(syscall_rename);
 509
 510         if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
 511                 errno = ENOENT;
 512                 goto out;
 513         }
 514
 515         result = rename(smb_fname_src->base_name, smb_fname_dst->base_name);
 516
 517  out:
 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,
 537                         struct smb_filename *smb_fname)
 538 {
 539         int result = -1;
 540
 541         START_PROFILE(syscall_stat);
 542
 543         if (smb_fname->stream_name) {
 544                 errno = ENOENT;
 545                 goto out;
 546         }
 547
 548         result = sys_stat(smb_fname->base_name, &smb_fname->st,
 549                           lp_fake_dir_create_times(SNUM(handle->conn)));
 550  out:
 551         END_PROFILE(syscall_stat);
 552         return result;
 553 }
 554
 555 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 556 {
 557         int result;
 558
 559         START_PROFILE(syscall_fstat);
 560         result = sys_fstat(fsp->fh->fd,
 561                            sbuf, lp_fake_dir_create_times(SNUM(handle->conn)));
 562         END_PROFILE(syscall_fstat);
 563         return result;
 564 }
 565
 566 static int vfswrap_lstat(vfs_handle_struct *handle,
 567                          struct smb_filename *smb_fname)
 568 {
 569         int result = -1;
 570
 571         START_PROFILE(syscall_lstat);
 572
 573         if (smb_fname->stream_name) {
 574                 errno = ENOENT;
 575                 goto out;
 576         }
 577
 578         result = sys_lstat(smb_fname->base_name, &smb_fname->st,
 579                            lp_fake_dir_create_times(SNUM(handle->conn)));
 580  out:
 581         END_PROFILE(syscall_lstat);
 582         return result;
 583 }
 584
 585 static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
 586                                        const char *name,
 587                                        enum vfs_translate_direction direction,
 588                                        TALLOC_CTX *mem_ctx,
 589                                        char **mapped_name)
 590 {
 591         return NT_STATUS_NONE_MAPPED;
 592 }
 593
 594 /********************************************************************
 595  Given a stat buffer return the allocated size on disk, taking into
 596  account sparse files.
 597 ********************************************************************/
 598 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
 599                                        struct files_struct *fsp,
 600                                        const SMB_STRUCT_STAT *sbuf)
 601 {
 602         uint64_t result;
 603
 604         START_PROFILE(syscall_get_alloc_size);
 605
 606         if(S_ISDIR(sbuf->st_ex_mode)) {
 607                 result = 0;
 608                 goto out;
 609         }
 610
 611 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
 612         result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
 613 #else
 614         result = get_file_size_stat(sbuf);
 615 #endif
 616
 617         if (fsp && fsp->initial_allocation_size)
 618                 result = MAX(result,fsp->initial_allocation_size);
 619
 620         result = smb_roundup(handle->conn, result);
 621
 622  out:
 623         END_PROFILE(syscall_get_alloc_size);
 624         return result;
 625 }
 626
 627 static int vfswrap_unlink(vfs_handle_struct *handle,
 628                           const struct smb_filename *smb_fname)
 629 {
 630         int result = -1;
 631
 632         START_PROFILE(syscall_unlink);
 633
 634         if (smb_fname->stream_name) {
 635                 errno = ENOENT;
 636                 goto out;
 637         }
 638         result = unlink(smb_fname->base_name);
 639
 640  out:
 641         END_PROFILE(syscall_unlink);
 642         return result;
 643 }
 644
 645 static int vfswrap_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
 646 {
 647         int result;
 648
 649         START_PROFILE(syscall_chmod);
 650
 651         /*
 652          * We need to do this due to the fact that the default POSIX ACL
 653          * chmod modifies the ACL *mask* for the group owner, not the
 654          * group owner bits directly. JRA.
 655          */
 656
 657
 658         {
 659                 int saved_errno = errno; /* We might get ENOSYS */
 660                 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
 661                         END_PROFILE(syscall_chmod);
 662                         return result;
 663                 }
 664                 /* Error - return the old errno. */
 665                 errno = saved_errno;
 666         }
 667
 668         result = chmod(path, mode);
 669         END_PROFILE(syscall_chmod);
 670         return result;
 671 }
 672
 673 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
 674 {
 675         int result;
 676
 677         START_PROFILE(syscall_fchmod);
 678
 679         /*
 680          * We need to do this due to the fact that the default POSIX ACL
 681          * chmod modifies the ACL *mask* for the group owner, not the
 682          * group owner bits directly. JRA.
 683          */
 684
 685         {
 686                 int saved_errno = errno; /* We might get ENOSYS */
 687                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
 688                         END_PROFILE(syscall_fchmod);
 689                         return result;
 690                 }
 691                 /* Error - return the old errno. */
 692                 errno = saved_errno;
 693         }
 694
 695 #if defined(HAVE_FCHMOD)
 696         result = fchmod(fsp->fh->fd, mode);
 697 #else
 698         result = -1;
 699         errno = ENOSYS;
 700 #endif
 701
 702         END_PROFILE(syscall_fchmod);
 703         return result;
 704 }
 705
 706 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 707 {
 708         int result;
 709
 710         START_PROFILE(syscall_chown);
 711         result = chown(path, uid, gid);
 712         END_PROFILE(syscall_chown);
 713         return result;
 714 }
 715
 716 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
 717 {
 718 #ifdef HAVE_FCHOWN
 719         int result;
 720
 721         START_PROFILE(syscall_fchown);
 722         result = fchown(fsp->fh->fd, uid, gid);
 723         END_PROFILE(syscall_fchown);
 724         return result;
 725 #else
 726         errno = ENOSYS;
 727         return -1;
 728 #endif
 729 }
 730
 731 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
 732 {
 733         int result;
 734
 735         START_PROFILE(syscall_lchown);
 736         result = lchown(path, uid, gid);
 737         END_PROFILE(syscall_lchown);
 738         return result;
 739 }
 740
 741 static int vfswrap_chdir(vfs_handle_struct *handle,  const char *path)
 742 {
 743         int result;
 744
 745         START_PROFILE(syscall_chdir);
 746         result = chdir(path);
 747         END_PROFILE(syscall_chdir);
 748         return result;
 749 }
 750
 751 static char *vfswrap_getwd(vfs_handle_struct *handle,  char *path)
 752 {
 753         char *result;
 754
 755         START_PROFILE(syscall_getwd);
 756         result = sys_getwd(path);
 757         END_PROFILE(syscall_getwd);
 758         return result;
 759 }
 760
 761 /*********************************************************************
 762  nsec timestamp resolution call. Convert down to whatever the underlying
 763  system will support.
 764 **********************************************************************/
 765
 766 static int vfswrap_ntimes(vfs_handle_struct *handle,
 767                           const struct smb_filename *smb_fname,
 768                           struct smb_file_time *ft)
 769 {
 770         int result = -1;
 771
 772         START_PROFILE(syscall_ntimes);
 773
 774         if (smb_fname->stream_name) {
 775                 errno = ENOENT;
 776                 goto out;
 777         }
 778
 779         if (ft != NULL) {
 780                 if (null_timespec(ft->atime)) {
 781                         ft->atime= smb_fname->st.st_ex_atime;
 782                 }
 783
 784                 if (null_timespec(ft->mtime)) {
 785                         ft->mtime = smb_fname->st.st_ex_mtime;
 786                 }
 787
 788                 if (!null_timespec(ft->create_time)) {
 789                         set_create_timespec_ea(handle->conn,
 790                                                smb_fname,
 791                                                ft->create_time);
 792                 }
 793
 794                 if ((timespec_compare(&ft->atime,
 795                                       &smb_fname->st.st_ex_atime) == 0) &&
 796                     (timespec_compare(&ft->mtime,
 797                                       &smb_fname->st.st_ex_mtime) == 0)) {
 798                         return 0;
 799                 }
 800         }
 801
 802 #if defined(HAVE_UTIMENSAT)
 803         if (ft != NULL) {
 804                 struct timespec ts[2];
 805                 ts[0] = ft->atime;
 806                 ts[1] = ft->mtime;
 807                 result = utimensat(AT_FDCWD, smb_fname->base_name, ts, 0);
 808         } else {
 809                 result = utimensat(AT_FDCWD, smb_fname->base_name, NULL, 0);
 810         }
 811         if (!((result == -1) && (errno == ENOSYS))) {
 812                 goto out;
 813         }
 814 #endif
 815 #if defined(HAVE_UTIMES)
 816         if (ft != NULL) {
 817                 struct timeval tv[2];
 818                 tv[0] = convert_timespec_to_timeval(ft->atime);
 819                 tv[1] = convert_timespec_to_timeval(ft->mtime);
 820                 result = utimes(smb_fname->base_name, tv);
 821         } else {
 822                 result = utimes(smb_fname->base_name, NULL);
 823         }
 824         if (!((result == -1) && (errno == ENOSYS))) {
 825                 goto out;
 826         }
 827 #endif
 828 #if defined(HAVE_UTIME)
 829         if (ft != NULL) {
 830                 struct utimbuf times;
 831                 times.actime = convert_timespec_to_time_t(ft->atime);
 832                 times.modtime = convert_timespec_to_time_t(ft->mtime);
 833                 result = utime(smb_fname->base_name, &times);
 834         } else {
 835                 result = utime(smb_fname->base_name, NULL);
 836         }
 837         if (!((result == -1) && (errno == ENOSYS))) {
 838                 goto out;
 839         }
 840 #endif
 841         errno = ENOSYS;
 842         result = -1;
 843
 844  out:
 845         END_PROFILE(syscall_ntimes);
 846         return result;
 847 }
 848
 849 /*********************************************************************
 850  A version of ftruncate that will write the space on disk if strict
 851  allocate is set.
 852 **********************************************************************/
 853
 854 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 855 {
 856         SMB_OFF_T space_to_write;
 857         uint64_t space_avail;
 858         uint64_t bsize,dfree,dsize;
 859         int ret;
 860         NTSTATUS status;
 861         SMB_STRUCT_STAT *pst;
 862
 863         status = vfs_stat_fsp(fsp);
 864         if (!NT_STATUS_IS_OK(status)) {
 865                 return -1;
 866         }
 867         pst = &fsp->fsp_name->st;
 868
 869 #ifdef S_ISFIFO
 870         if (S_ISFIFO(pst->st_ex_mode))
 871                 return 0;
 872 #endif
 873
 874         if (pst->st_ex_size == len)
 875                 return 0;
 876
 877         /* Shrink - just ftruncate. */
 878         if (pst->st_ex_size > len)
 879                 return sys_ftruncate(fsp->fh->fd, len);
 880
 881         space_to_write = len - pst->st_ex_size;
 882
 883         /* for allocation try fallocate first. This can fail on some
 884            platforms e.g. when the filesystem doesn't support it and no
 885            emulation is being done by the libc (like on AIX with JFS1). In that
 886            case we do our own emulation. fallocate implementations can
 887            return ENOTSUP or EINVAL in cases like that. */
 888         ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
 889                                 pst->st_ex_size, space_to_write);
 890         if (ret == ENOSPC) {
 891                 errno = ENOSPC;
 892                 return -1;
 893         }
 894         if (ret == 0) {
 895                 return 0;
 896         }
 897         DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
 898                 "error %d. Falling back to slow manual allocation\n", ret));
 899
 900         /* available disk space is enough or not? */
 901         space_avail = get_dfree_info(fsp->conn,
 902                                      fsp->fsp_name->base_name, false,
 903                                      &bsize,&dfree,&dsize);
 904         /* space_avail is 1k blocks */
 905         if (space_avail == (uint64_t)-1 ||
 906                         ((uint64_t)space_to_write/1024 > space_avail) ) {
 907                 errno = ENOSPC;
 908                 return -1;
 909         }
 910
 911         /* Write out the real space on disk. */
 912         ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
 913         if (ret != 0) {
 914                 errno = ret;
 915                 ret = -1;
 916         }
 917
 918         return 0;
 919 }
 920
 921 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
 922 {
 923         int result = -1;
 924         SMB_STRUCT_STAT *pst;
 925         NTSTATUS status;
 926         char c = 0;
 927
 928         START_PROFILE(syscall_ftruncate);
 929
 930         if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->is_sparse) {
 931                 result = strict_allocate_ftruncate(handle, fsp, len);
 932                 END_PROFILE(syscall_ftruncate);
 933                 return result;
 934         }
 935
 936         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
 937            sys_ftruncate if the system supports it. Then I discovered that
 938            you can have some filesystems that support ftruncate
 939            expansion and some that don't! On Linux fat can't do
 940            ftruncate extend but ext2 can. */
 941
 942         result = sys_ftruncate(fsp->fh->fd, len);
 943         if (result == 0)
 944                 goto done;
 945
 946         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
 947            extend a file with ftruncate. Provide alternate implementation
 948            for this */
 949
 950         /* Do an fstat to see if the file is longer than the requested
 951            size in which case the ftruncate above should have
 952            succeeded or shorter, in which case seek to len - 1 and
 953            write 1 byte of zero */
 954         status = vfs_stat_fsp(fsp);
 955         if (!NT_STATUS_IS_OK(status)) {
 956                 goto done;
 957         }
 958         pst = &fsp->fsp_name->st;
 959
 960 #ifdef S_ISFIFO
 961         if (S_ISFIFO(pst->st_ex_mode)) {
 962                 result = 0;
 963                 goto done;
 964         }
 965 #endif
 966
 967         if (pst->st_ex_size == len) {
 968                 result = 0;
 969                 goto done;
 970         }
 971
 972         if (pst->st_ex_size > len) {
 973                 /* the sys_ftruncate should have worked */
 974                 goto done;
 975         }
 976
 977         if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
 978                 goto done;
 979         }
 980
 981         result = 0;
 982
 983   done:
 984
 985         END_PROFILE(syscall_ftruncate);
 986         return result;
 987 }
 988
 989 static int vfswrap_fallocate(vfs_handle_struct *handle,
 990                         files_struct *fsp,
 991                         enum vfs_fallocate_mode mode,
 992                         SMB_OFF_T offset,
 993                         SMB_OFF_T len)
 994 {
 995         int result;
 996
 997         START_PROFILE(syscall_fallocate);
 998         if (mode == VFS_FALLOCATE_EXTEND_SIZE) {
 999                 result = sys_posix_fallocate(fsp->fh->fd, offset, len);
1000         } else if (mode == VFS_FALLOCATE_KEEP_SIZE) {
1001                 result = sys_fallocate(fsp->fh->fd, mode, offset, len);
1002         } else {
1003                 errno = EINVAL;
1004                 result = -1;
1005         }
1006         END_PROFILE(syscall_fallocate);
1007         return result;
1008 }
1009
1010 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
1011 {
1012         bool result;
1013
1014         START_PROFILE(syscall_fcntl_lock);
1015         result =  fcntl_lock(fsp->fh->fd, op, offset, count, type);
1016         END_PROFILE(syscall_fcntl_lock);
1017         return result;
1018 }
1019
1020 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
1021                                 uint32 share_mode, uint32 access_mask)
1022 {
1023         START_PROFILE(syscall_kernel_flock);
1024         kernel_flock(fsp->fh->fd, share_mode, access_mask);
1025         END_PROFILE(syscall_kernel_flock);
1026         return 0;
1027 }
1028
1029 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
1030 {
1031         bool result;
1032
1033         START_PROFILE(syscall_fcntl_getlock);
1034         result =  fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
1035         END_PROFILE(syscall_fcntl_getlock);
1036         return result;
1037 }
1038
1039 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
1040                                 int leasetype)
1041 {
1042         int result = -1;
1043
1044         START_PROFILE(syscall_linux_setlease);
1045
1046 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
1047         result = linux_setlease(fsp->fh->fd, leasetype);
1048 #else
1049         errno = ENOSYS;
1050 #endif
1051         END_PROFILE(syscall_linux_setlease);
1052         return result;
1053 }
1054
1055 static int vfswrap_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1056 {
1057         int result;
1058
1059         START_PROFILE(syscall_symlink);
1060         result = symlink(oldpath, newpath);
1061         END_PROFILE(syscall_symlink);
1062         return result;
1063 }
1064
1065 static int vfswrap_readlink(vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
1066 {
1067         int result;
1068
1069         START_PROFILE(syscall_readlink);
1070         result = readlink(path, buf, bufsiz);
1071         END_PROFILE(syscall_readlink);
1072         return result;
1073 }
1074
1075 static int vfswrap_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1076 {
1077         int result;
1078
1079         START_PROFILE(syscall_link);
1080         result = link(oldpath, newpath);
1081         END_PROFILE(syscall_link);
1082         return result;
1083 }
1084
1085 static int vfswrap_mknod(vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
1086 {
1087         int result;
1088
1089         START_PROFILE(syscall_mknod);
1090         result = sys_mknod(pathname, mode, dev);
1091         END_PROFILE(syscall_mknod);
1092         return result;
1093 }
1094
1095 static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path)
1096 {
1097         char *result;
1098
1099         START_PROFILE(syscall_realpath);
1100 #ifdef REALPATH_TAKES_NULL
1101         result = realpath(path, NULL);
1102 #else
1103         result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
1104         if (result) {
1105                 char *resolved_path = realpath(path, result);
1106                 if (!resolved_path) {
1107                         SAFE_FREE(result);
1108                 } else {
1109                         /* SMB_ASSERT(result == resolved_path) ? */
1110                         result = resolved_path;
1111                 }
1112         }
1113 #endif
1114         END_PROFILE(syscall_realpath);
1115         return result;
1116 }
1117
1118 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
1119                                      struct sys_notify_context *ctx,
1120                                      struct notify_entry *e,
1121                                      void (*callback)(struct sys_notify_context *ctx,
1122                                                       void *private_data,
1123                                                       struct notify_event *ev),
1124                                      void *private_data, void *handle)
1125 {
1126         /*
1127          * So far inotify is the only supported default notify mechanism. If
1128          * another platform like the the BSD's or a proprietary Unix comes
1129          * along and wants another default, we can play the same trick we
1130          * played with Posix ACLs.
1131          *
1132          * Until that is the case, hard-code inotify here.
1133          */
1134 #ifdef HAVE_INOTIFY
1135         if (lp_kernel_change_notify(ctx->conn->params)) {
1136                 return inotify_watch(ctx, e, callback, private_data, handle);
1137         }
1138 #endif
1139         /*
1140          * Do nothing, leave everything to notify_internal.c
1141          */
1142         return NT_STATUS_OK;
1143 }
1144
1145 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path,
1146                            unsigned int flags)
1147 {
1148 #ifdef HAVE_CHFLAGS
1149         return chflags(path, flags);
1150 #else
1151         errno = ENOSYS;
1152         return -1;
1153 #endif
1154 }
1155
1156 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
1157                                              const SMB_STRUCT_STAT *sbuf)
1158 {
1159         struct file_id key;
1160
1161         /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1162          * blob */
1163         ZERO_STRUCT(key);
1164
1165         key.devid = sbuf->st_ex_dev;
1166         key.inode = sbuf->st_ex_ino;
1167         /* key.extid is unused by default. */
1168
1169         return key;
1170 }
1171
1172 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1173                                    struct files_struct *fsp,
1174                                    const char *fname,
1175                                    TALLOC_CTX *mem_ctx,
1176                                    unsigned int *pnum_streams,
1177                                    struct stream_struct **pstreams)
1178 {
1179         SMB_STRUCT_STAT sbuf;
1180         struct stream_struct *tmp_streams = NULL;
1181         int ret;
1182
1183         if ((fsp != NULL) && (fsp->is_directory)) {
1184                 /*
1185                  * No default streams on directories
1186                  */
1187                 goto done;
1188         }
1189
1190         if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1191                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1192         }
1193         else {
1194                 struct smb_filename smb_fname;
1195
1196                 ZERO_STRUCT(smb_fname);
1197                 smb_fname.base_name = discard_const_p(char, fname);
1198
1199                 if (lp_posix_pathnames()) {
1200                         ret = SMB_VFS_LSTAT(handle->conn, &smb_fname);
1201                 } else {
1202                         ret = SMB_VFS_STAT(handle->conn, &smb_fname);
1203                 }
1204                 sbuf = smb_fname.st;
1205         }
1206
1207         if (ret == -1) {
1208                 return map_nt_error_from_unix(errno);
1209         }
1210
1211         if (S_ISDIR(sbuf.st_ex_mode)) {
1212                 goto done;
1213         }
1214
1215         tmp_streams = talloc_realloc(mem_ctx, *pstreams, struct stream_struct,
1216                                         (*pnum_streams) + 1);
1217         if (tmp_streams == NULL) {
1218                 return NT_STATUS_NO_MEMORY;
1219         }
1220         tmp_streams[*pnum_streams].name = talloc_strdup(tmp_streams, "::$DATA");
1221         if (tmp_streams[*pnum_streams].name == NULL) {
1222                 return NT_STATUS_NO_MEMORY;
1223         }
1224         tmp_streams[*pnum_streams].size = sbuf.st_ex_size;
1225         tmp_streams[*pnum_streams].alloc_size = SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp, &sbuf);
1226
1227         *pnum_streams += 1;
1228         *pstreams = tmp_streams;
1229  done:
1230         return NT_STATUS_OK;
1231 }
1232
1233 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1234                                      const char *path,
1235                                      const char *name,
1236                                      TALLOC_CTX *mem_ctx,
1237                                      char **found_name)
1238 {
1239         /*
1240          * Don't fall back to get_real_filename so callers can differentiate
1241          * between a full directory scan and an actual case-insensitive stat.
1242          */
1243         errno = EOPNOTSUPP;
1244         return -1;
1245 }
1246
1247 static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
1248                                        const char *fname)
1249 {
1250         return handle->conn->connectpath;
1251 }
1252
1253 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
1254                                          struct byte_range_lock *br_lck,
1255                                          struct lock_struct *plock,
1256                                          bool blocking_lock,
1257                                          struct blocking_lock_record *blr)
1258 {
1259         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1260
1261         /* Note: blr is not used in the default implementation. */
1262         return brl_lock_windows_default(br_lck, plock, blocking_lock);
1263 }
1264
1265 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
1266                                        struct messaging_context *msg_ctx,
1267                                        struct byte_range_lock *br_lck,
1268                                        const struct lock_struct *plock)
1269 {
1270         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1271
1272         return brl_unlock_windows_default(msg_ctx, br_lck, plock);
1273 }
1274
1275 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
1276                                        struct byte_range_lock *br_lck,
1277                                        struct lock_struct *plock,
1278                                        struct blocking_lock_record *blr)
1279 {
1280         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
1281
1282         /* Note: blr is not used in the default implementation. */
1283         return brl_lock_cancel_default(br_lck, plock);
1284 }
1285
1286 static bool vfswrap_strict_lock(struct vfs_handle_struct *handle,
1287                                 files_struct *fsp,
1288                                 struct lock_struct *plock)
1289 {
1290         SMB_ASSERT(plock->lock_type == READ_LOCK ||
1291             plock->lock_type == WRITE_LOCK);
1292
1293         return strict_lock_default(fsp, plock);
1294 }
1295
1296 static void vfswrap_strict_unlock(struct vfs_handle_struct *handle,
1297                                 files_struct *fsp,
1298                                 struct lock_struct *plock)
1299 {
1300         SMB_ASSERT(plock->lock_type == READ_LOCK ||
1301             plock->lock_type == WRITE_LOCK);
1302
1303         strict_unlock_default(fsp, plock);
1304 }
1305
1306 /* NT ACL operations. */
1307
1308 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1309                                     files_struct *fsp,
1310                                     uint32 security_info,
1311                                     struct security_descriptor **ppdesc)
1312 {
1313         NTSTATUS result;
1314
1315         START_PROFILE(fget_nt_acl);
1316         result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1317         END_PROFILE(fget_nt_acl);
1318         return result;
1319 }
1320
1321 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1322                                    const char *name,
1323                                    uint32 security_info,
1324                                    struct security_descriptor **ppdesc)
1325 {
1326         NTSTATUS result;
1327
1328         START_PROFILE(get_nt_acl);
1329         result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1330         END_PROFILE(get_nt_acl);
1331         return result;
1332 }
1333
1334 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
1335 {
1336         NTSTATUS result;
1337
1338         START_PROFILE(fset_nt_acl);
1339         result = set_nt_acl(fsp, security_info_sent, psd);
1340         END_PROFILE(fset_nt_acl);
1341         return result;
1342 }
1343
1344 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
1345 {
1346 #ifdef HAVE_NO_ACL
1347         errno = ENOSYS;
1348         return -1;
1349 #else
1350         int result;
1351
1352         START_PROFILE(chmod_acl);
1353         result = chmod_acl(handle->conn, name, mode);
1354         END_PROFILE(chmod_acl);
1355         return result;
1356 #endif
1357 }
1358
1359 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1360 {
1361 #ifdef HAVE_NO_ACL
1362         errno = ENOSYS;
1363         return -1;
1364 #else
1365         int result;
1366
1367         START_PROFILE(fchmod_acl);
1368         result = fchmod_acl(fsp, mode);
1369         END_PROFILE(fchmod_acl);
1370         return result;
1371 #endif
1372 }
1373
1374 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle,  SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1375 {
1376         return sys_acl_get_entry(theacl, entry_id, entry_p);
1377 }
1378
1379 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)
1380 {
1381         return sys_acl_get_tag_type(entry_d, tag_type_p);
1382 }
1383
1384 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1385 {
1386         return sys_acl_get_permset(entry_d, permset_p);
1387 }
1388
1389 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry_d)
1390 {
1391         return sys_acl_get_qualifier(entry_d);
1392 }
1393
1394 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,  const char *path_p, SMB_ACL_TYPE_T type)
1395 {
1396         return sys_acl_get_file(handle, path_p, type);
1397 }
1398
1399 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1400 {
1401         return sys_acl_get_fd(handle, fsp);
1402 }
1403
1404 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset)
1405 {
1406         return sys_acl_clear_perms(permset);
1407 }
1408
1409 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1410 {
1411         return sys_acl_add_perm(permset, perm);
1412 }
1413
1414 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle,  SMB_ACL_T theacl, ssize_t *plen)
1415 {
1416         return sys_acl_to_text(theacl, plen);
1417 }
1418
1419 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle,  int count)
1420 {
1421         return sys_acl_init(count);
1422 }
1423
1424 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle,  SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1425 {
1426         return sys_acl_create_entry(pacl, pentry);
1427 }
1428
1429 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1430 {
1431         return sys_acl_set_tag_type(entry, tagtype);
1432 }
1433
1434 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, void *qual)
1435 {
1436         return sys_acl_set_qualifier(entry, qual);
1437 }
1438
1439 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle,  SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1440 {
1441         return sys_acl_set_permset(entry, permset);
1442 }
1443
1444 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle,  SMB_ACL_T theacl )
1445 {
1446         return sys_acl_valid(theacl );
1447 }
1448
1449 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1450 {
1451         return sys_acl_set_file(handle, name, acltype, theacl);
1452 }
1453
1454 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1455 {
1456         return sys_acl_set_fd(handle, fsp, theacl);
1457 }
1458
1459 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
1460 {
1461         return sys_acl_delete_def_file(handle, path);
1462 }
1463
1464 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle,  SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1465 {
1466         return sys_acl_get_perm(permset, perm);
1467 }
1468
1469 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle,  char *text)
1470 {
1471         return sys_acl_free_text(text);
1472 }
1473
1474 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle,  SMB_ACL_T posix_acl)
1475 {
1476         return sys_acl_free_acl(posix_acl);
1477 }
1478
1479 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle,  void *qualifier, SMB_ACL_TAG_T tagtype)
1480 {
1481         return sys_acl_free_qualifier(qualifier, tagtype);
1482 }
1483
1484 /****************************************************************
1485  Extended attribute operations.
1486 *****************************************************************/
1487
1488 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1489 {
1490         return sys_getxattr(path, name, value, size);
1491 }
1492
1493 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1494 {
1495         return sys_lgetxattr(path, name, value, size);
1496 }
1497
1498 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1499 {
1500         return sys_fgetxattr(fsp->fh->fd, name, value, size);
1501 }
1502
1503 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1504 {
1505         return sys_listxattr(path, list, size);
1506 }
1507
1508 static ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1509 {
1510         return sys_llistxattr(path, list, size);
1511 }
1512
1513 static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1514 {
1515         return sys_flistxattr(fsp->fh->fd, list, size);
1516 }
1517
1518 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1519 {
1520         return sys_removexattr(path, name);
1521 }
1522
1523 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1524 {
1525         return sys_lremovexattr(path, name);
1526 }
1527
1528 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1529 {
1530         return sys_fremovexattr(fsp->fh->fd, name);
1531 }
1532
1533 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1534 {
1535         return sys_setxattr(path, name, value, size, flags);
1536 }
1537
1538 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1539 {
1540         return sys_lsetxattr(path, name, value, size, flags);
1541 }
1542
1543 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1544 {
1545         return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1546 }
1547
1548 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1549 {
1550         int ret;
1551         /*
1552          * aio_read must be done as root, because in the glibc aio
1553          * implementation the helper thread needs to be able to send a signal
1554          * to the main thread, even when it has done a seteuid() to a
1555          * different user.
1556          */
1557         become_root();
1558         ret = sys_aio_read(aiocb);
1559         unbecome_root();
1560         return ret;
1561 }
1562
1563 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1564 {
1565         int ret;
1566         /*
1567          * aio_write must be done as root, because in the glibc aio
1568          * implementation the helper thread needs to be able to send a signal
1569          * to the main thread, even when it has done a seteuid() to a
1570          * different user.
1571          */
1572         become_root();
1573         ret = sys_aio_write(aiocb);
1574         unbecome_root();
1575         return ret;
1576 }
1577
1578 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1579 {
1580         return sys_aio_return(aiocb);
1581 }
1582
1583 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1584 {
1585         return sys_aio_cancel(fsp->fh->fd, aiocb);
1586 }
1587
1588 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1589 {
1590         return sys_aio_error(aiocb);
1591 }
1592
1593 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1594 {
1595         return sys_aio_fsync(op, aiocb);
1596 }
1597
1598 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)
1599 {
1600         return sys_aio_suspend(aiocb, n, timeout);
1601 }
1602
1603 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1604 {
1605         return false;
1606 }
1607
1608 static bool vfswrap_is_offline(struct vfs_handle_struct *handle,
1609                                const struct smb_filename *fname,
1610                                SMB_STRUCT_STAT *sbuf)
1611 {
1612         NTSTATUS status;
1613         char *path;
1614
1615         if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
1616                 return false;
1617         }
1618
1619         if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1620 #if defined(ENOTSUP)
1621                 errno = ENOTSUP;
1622 #endif
1623                 return false;
1624         }
1625
1626         status = get_full_smb_filename(talloc_tos(), fname, &path);
1627         if (!NT_STATUS_IS_OK(status)) {
1628                 errno = map_errno_from_nt_status(status);
1629                 return false;
1630         }
1631
1632         return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1633 }
1634
1635 static int vfswrap_set_offline(struct vfs_handle_struct *handle,
1636                                const struct smb_filename *fname)
1637 {
1638         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1639 #if defined(ENOTSUP)
1640         errno = ENOTSUP;
1641 #endif
1642         return -1;
1643 }
1644
1645 static struct vfs_fn_pointers vfs_default_fns = {
1646         /* Disk operations */
1647
1648         .connect_fn = vfswrap_connect,
1649         .disconnect = vfswrap_disconnect,
1650         .disk_free = vfswrap_disk_free,
1651         .get_quota = vfswrap_get_quota,
1652         .set_quota = vfswrap_set_quota,
1653         .get_shadow_copy_data = vfswrap_get_shadow_copy_data,
1654         .statvfs = vfswrap_statvfs,
1655         .fs_capabilities = vfswrap_fs_capabilities,
1656
1657         /* Directory operations */
1658
1659         .opendir = vfswrap_opendir,
1660         .fdopendir = vfswrap_fdopendir,
1661         .readdir = vfswrap_readdir,
1662         .seekdir = vfswrap_seekdir,
1663         .telldir = vfswrap_telldir,
1664         .rewind_dir = vfswrap_rewinddir,
1665         .mkdir = vfswrap_mkdir,
1666         .rmdir = vfswrap_rmdir,
1667         .closedir = vfswrap_closedir,
1668         .init_search_op = vfswrap_init_search_op,
1669
1670         /* File operations */
1671
1672         .open_fn = vfswrap_open,
1673         .create_file = vfswrap_create_file,
1674         .close_fn = vfswrap_close,
1675         .vfs_read = vfswrap_read,
1676         .pread = vfswrap_pread,
1677         .write = vfswrap_write,
1678         .pwrite = vfswrap_pwrite,
1679         .lseek = vfswrap_lseek,
1680         .sendfile = vfswrap_sendfile,
1681         .recvfile = vfswrap_recvfile,
1682         .rename = vfswrap_rename,
1683         .fsync = vfswrap_fsync,
1684         .stat = vfswrap_stat,
1685         .fstat = vfswrap_fstat,
1686         .lstat = vfswrap_lstat,
1687         .get_alloc_size = vfswrap_get_alloc_size,
1688         .unlink = vfswrap_unlink,
1689         .chmod = vfswrap_chmod,
1690         .fchmod = vfswrap_fchmod,
1691         .chown = vfswrap_chown,
1692         .fchown = vfswrap_fchown,
1693         .lchown = vfswrap_lchown,
1694         .chdir = vfswrap_chdir,
1695         .getwd = vfswrap_getwd,
1696         .ntimes = vfswrap_ntimes,
1697         .ftruncate = vfswrap_ftruncate,
1698         .fallocate = vfswrap_fallocate,
1699         .lock = vfswrap_lock,
1700         .kernel_flock = vfswrap_kernel_flock,
1701         .linux_setlease = vfswrap_linux_setlease,
1702         .getlock = vfswrap_getlock,
1703         .symlink = vfswrap_symlink,
1704         .vfs_readlink = vfswrap_readlink,
1705         .link = vfswrap_link,
1706         .mknod = vfswrap_mknod,
1707         .realpath = vfswrap_realpath,
1708         .notify_watch = vfswrap_notify_watch,
1709         .chflags = vfswrap_chflags,
1710         .file_id_create = vfswrap_file_id_create,
1711         .streaminfo = vfswrap_streaminfo,
1712         .get_real_filename = vfswrap_get_real_filename,
1713         .connectpath = vfswrap_connectpath,
1714         .brl_lock_windows = vfswrap_brl_lock_windows,
1715         .brl_unlock_windows = vfswrap_brl_unlock_windows,
1716         .brl_cancel_windows = vfswrap_brl_cancel_windows,
1717         .strict_lock = vfswrap_strict_lock,
1718         .strict_unlock = vfswrap_strict_unlock,
1719         .translate_name = vfswrap_translate_name,
1720
1721         /* NT ACL operations. */
1722
1723         .fget_nt_acl = vfswrap_fget_nt_acl,
1724         .get_nt_acl = vfswrap_get_nt_acl,
1725         .fset_nt_acl = vfswrap_fset_nt_acl,
1726
1727         /* POSIX ACL operations. */
1728
1729         .chmod_acl = vfswrap_chmod_acl,
1730         .fchmod_acl = vfswrap_fchmod_acl,
1731
1732         .sys_acl_get_entry = vfswrap_sys_acl_get_entry,
1733         .sys_acl_get_tag_type = vfswrap_sys_acl_get_tag_type,
1734         .sys_acl_get_permset = vfswrap_sys_acl_get_permset,
1735         .sys_acl_get_qualifier = vfswrap_sys_acl_get_qualifier,
1736         .sys_acl_get_file = vfswrap_sys_acl_get_file,
1737         .sys_acl_get_fd = vfswrap_sys_acl_get_fd,
1738         .sys_acl_clear_perms = vfswrap_sys_acl_clear_perms,
1739         .sys_acl_add_perm = vfswrap_sys_acl_add_perm,
1740         .sys_acl_to_text = vfswrap_sys_acl_to_text,
1741         .sys_acl_init = vfswrap_sys_acl_init,
1742         .sys_acl_create_entry = vfswrap_sys_acl_create_entry,
1743         .sys_acl_set_tag_type = vfswrap_sys_acl_set_tag_type,
1744         .sys_acl_set_qualifier = vfswrap_sys_acl_set_qualifier,
1745         .sys_acl_set_permset = vfswrap_sys_acl_set_permset,
1746         .sys_acl_valid = vfswrap_sys_acl_valid,
1747         .sys_acl_set_file = vfswrap_sys_acl_set_file,
1748         .sys_acl_set_fd = vfswrap_sys_acl_set_fd,
1749         .sys_acl_delete_def_file = vfswrap_sys_acl_delete_def_file,
1750         .sys_acl_get_perm = vfswrap_sys_acl_get_perm,
1751         .sys_acl_free_text = vfswrap_sys_acl_free_text,
1752         .sys_acl_free_acl = vfswrap_sys_acl_free_acl,
1753         .sys_acl_free_qualifier = vfswrap_sys_acl_free_qualifier,
1754
1755         /* EA operations. */
1756         .getxattr = vfswrap_getxattr,
1757         .lgetxattr = vfswrap_lgetxattr,
1758         .fgetxattr = vfswrap_fgetxattr,
1759         .listxattr = vfswrap_listxattr,
1760         .llistxattr = vfswrap_llistxattr,
1761         .flistxattr = vfswrap_flistxattr,
1762         .removexattr = vfswrap_removexattr,
1763         .lremovexattr = vfswrap_lremovexattr,
1764         .fremovexattr = vfswrap_fremovexattr,
1765         .setxattr = vfswrap_setxattr,
1766         .lsetxattr = vfswrap_lsetxattr,
1767         .fsetxattr = vfswrap_fsetxattr,
1768
1769         /* aio operations */
1770         .aio_read = vfswrap_aio_read,
1771         .aio_write = vfswrap_aio_write,
1772         .aio_return_fn = vfswrap_aio_return,
1773         .aio_cancel = vfswrap_aio_cancel,
1774         .aio_error_fn = vfswrap_aio_error,
1775         .aio_fsync = vfswrap_aio_fsync,
1776         .aio_suspend = vfswrap_aio_suspend,
1777         .aio_force = vfswrap_aio_force,
1778
1779         /* offline operations */
1780         .is_offline = vfswrap_is_offline,
1781         .set_offline = vfswrap_set_offline
1782 };
1783
1784 NTSTATUS vfs_default_init(void);
1785 NTSTATUS vfs_default_init(void)
1786 {
1787         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1788                                 DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
1789 }
1790
1791