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