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 "smbd/globals.h"
  26 #include "ntioctl.h"
  27 #include "smbprofile.h"
  28 #include "../libcli/security/security.h"
  29 #include "passdb/lookup_sid.h"
  30 #include "source3/include/msdfs.h"
  31 #include "librpc/gen_ndr/ndr_dfsblobs.h"
  32 #include "lib/util/tevent_unix.h"
  33 #include "lib/util/tevent_ntstatus.h"
  34 #include "lib/util/sys_rw.h"
  35 #include "lib/pthreadpool/pthreadpool_tevent.h"
  36 #include "librpc/gen_ndr/ndr_ioctl.h"
  37 #include "offload_token.h"
  38 #include "util_reparse.h"
  39 #include "lib/util/string_wrappers.h"
  40
  41 #undef DBGC_CLASS
  42 #define DBGC_CLASS DBGC_VFS
  43
  44 /* Check for NULL pointer parameters in vfswrap_* functions */
  45
  46 /* We don't want to have NULL function pointers lying around.  Someone
  47    is sure to try and execute them.  These stubs are used to prevent
  48    this possibility. */
  49
  50 static int vfswrap_connect(vfs_handle_struct *handle, const char *service, const char *user)
  51 {
  52         handle->conn->have_proc_fds = sys_have_proc_fds();
  53         return 0;    /* Return >= 0 for success */
  54 }
  55
  56 static void vfswrap_disconnect(vfs_handle_struct *handle)
  57 {
  58 }
  59
  60 /* Disk operations */
  61
  62 static uint64_t vfswrap_disk_free(vfs_handle_struct *handle,
  63                                 const struct smb_filename *smb_fname,
  64                                 uint64_t *bsize,
  65                                 uint64_t *dfree,
  66                                 uint64_t *dsize)
  67 {
  68         if (sys_fsusage(smb_fname->base_name, dfree, dsize) != 0) {
  69                 return (uint64_t)-1;
  70         }
  71
  72         *bsize = 512;
  73         return *dfree / 2;
  74 }
  75
  76 static int vfswrap_get_quota(struct vfs_handle_struct *handle,
  77                                 const struct smb_filename *smb_fname,
  78                                 enum SMB_QUOTA_TYPE qtype,
  79                                 unid_t id,
  80                                 SMB_DISK_QUOTA *qt)
  81 {
  82 #ifdef HAVE_SYS_QUOTAS
  83         int result;
  84
  85         START_PROFILE(syscall_get_quota);
  86         result = sys_get_quota(smb_fname->base_name, qtype, id, qt);
  87         END_PROFILE(syscall_get_quota);
  88         return result;
  89 #else
  90         errno = ENOSYS;
  91         return -1;
  92 #endif
  93 }
  94
  95 static int vfswrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  96 {
  97 #ifdef HAVE_SYS_QUOTAS
  98         int result;
  99
 100         START_PROFILE(syscall_set_quota);
 101         result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
 102         END_PROFILE(syscall_set_quota);
 103         return result;
 104 #else
 105         errno = ENOSYS;
 106         return -1;
 107 #endif
 108 }
 109
 110 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
 111                                         struct files_struct *fsp,
 112                                         struct shadow_copy_data *shadow_copy_data,
 113                                         bool labels)
 114 {
 115         errno = ENOSYS;
 116         return -1;  /* Not implemented. */
 117 }
 118
 119 static int vfswrap_statvfs(struct vfs_handle_struct *handle,
 120                                 const struct smb_filename *smb_fname,
 121                                 vfs_statvfs_struct *statbuf)
 122 {
 123         return sys_statvfs(smb_fname->base_name, statbuf);
 124 }
 125
 126 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
 127                 enum timestamp_set_resolution *p_ts_res)
 128 {
 129         const struct loadparm_substitution *lp_sub =
 130                 loadparm_s3_global_substitution();
 131         connection_struct *conn = handle->conn;
 132         uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
 133         struct smb_filename *smb_fname_cpath = NULL;
 134         struct vfs_statvfs_struct statbuf;
 135         int ret;
 136
 137         smb_fname_cpath = synthetic_smb_fname(talloc_tos(),
 138                                               conn->connectpath,
 139                                               NULL,
 140                                               NULL,
 141                                               0,
 142                                               0);
 143         if (smb_fname_cpath == NULL) {
 144                 return caps;
 145         }
 146
 147         ZERO_STRUCT(statbuf);
 148         ret = SMB_VFS_STATVFS(conn, smb_fname_cpath, &statbuf);
 149         if (ret == 0) {
 150                 caps = statbuf.FsCapabilities;
 151         }
 152
 153         *p_ts_res = TIMESTAMP_SET_SECONDS;
 154
 155         /* Work out what timestamp resolution we can
 156          * use when setting a timestamp. */
 157
 158         ret = SMB_VFS_STAT(conn, smb_fname_cpath);
 159         if (ret == -1) {
 160                 TALLOC_FREE(smb_fname_cpath);
 161                 return caps;
 162         }
 163
 164         if (smb_fname_cpath->st.st_ex_mtime.tv_nsec ||
 165                         smb_fname_cpath->st.st_ex_atime.tv_nsec ||
 166                         smb_fname_cpath->st.st_ex_ctime.tv_nsec) {
 167                 /* If any of the normal UNIX directory timestamps
 168                  * have a non-zero tv_nsec component assume
 169                  * we might be able to set sub-second timestamps.
 170                  * See what filetime set primitives we have.
 171                  */
 172 #if defined(HAVE_UTIMENSAT)
 173                 *p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
 174 #elif defined(HAVE_UTIMES)
 175                 /* utimes allows msec timestamps to be set. */
 176                 *p_ts_res = TIMESTAMP_SET_MSEC;
 177 #elif defined(HAVE_UTIME)
 178                 /* utime only allows sec timestamps to be set. */
 179                 *p_ts_res = TIMESTAMP_SET_SECONDS;
 180 #endif
 181
 182                 DEBUG(10,("vfswrap_fs_capabilities: timestamp "
 183                         "resolution of %s "
 184                         "available on share %s, directory %s\n",
 185                         *p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
 186                         lp_servicename(talloc_tos(), lp_sub, conn->params->service),
 187                         conn->connectpath ));
 188         }
 189         TALLOC_FREE(smb_fname_cpath);
 190         return caps;
 191 }
 192
 193 static NTSTATUS vfswrap_get_dfs_referrals(struct vfs_handle_struct *handle,
 194                                           struct dfs_GetDFSReferral *r)
 195 {
 196         struct junction_map *junction = NULL;
 197         int consumedcnt = 0;
 198         bool self_referral = false;
 199         char *pathnamep = NULL;
 200         char *local_dfs_path = NULL;
 201         NTSTATUS status;
 202         size_t i;
 203         uint16_t max_referral_level = r->in.req.max_referral_level;
 204
 205         if (DEBUGLVL(10)) {
 206                 NDR_PRINT_IN_DEBUG(dfs_GetDFSReferral, r);
 207         }
 208
 209         /* get the junction entry */
 210         if (r->in.req.servername == NULL) {
 211                 return NT_STATUS_NOT_FOUND;
 212         }
 213
 214         /*
 215          * Trim pathname sent by client so it begins with only one backslash.
 216          * Two backslashes confuse some dfs clients
 217          */
 218
 219         local_dfs_path = talloc_strdup(r, r->in.req.servername);
 220         if (local_dfs_path == NULL) {
 221                 return NT_STATUS_NO_MEMORY;
 222         }
 223         pathnamep = local_dfs_path;
 224         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
 225                IS_DIRECTORY_SEP(pathnamep[1])) {
 226                 pathnamep++;
 227         }
 228
 229         junction = talloc_zero(r, struct junction_map);
 230         if (junction == NULL) {
 231                 return NT_STATUS_NO_MEMORY;
 232         }
 233
 234         /* The following call can change cwd. */
 235         status = get_referred_path(r,
 236                                    handle->conn->session_info,
 237                                    pathnamep,
 238                                    handle->conn->sconn->remote_address,
 239                                    handle->conn->sconn->local_address,
 240                                    !handle->conn->sconn->using_smb2,
 241                                    junction, &consumedcnt, &self_referral);
 242         if (!NT_STATUS_IS_OK(status)) {
 243                 struct smb_filename connectpath_fname = {
 244                         .base_name = handle->conn->connectpath
 245                 };
 246                 vfs_ChDir(handle->conn, &connectpath_fname);
 247                 return status;
 248         }
 249         {
 250                 struct smb_filename connectpath_fname = {
 251                         .base_name = handle->conn->connectpath
 252                 };
 253                 vfs_ChDir(handle->conn, &connectpath_fname);
 254         }
 255
 256         if (!self_referral) {
 257                 pathnamep[consumedcnt] = '\0';
 258
 259                 if (DEBUGLVL(3)) {
 260                         dbgtext("Path %s to alternate path(s):",
 261                                 pathnamep);
 262                         for (i=0; i < junction->referral_count; i++) {
 263                                 dbgtext(" %s",
 264                                 junction->referral_list[i].alternate_path);
 265                         }
 266                         dbgtext(".\n");
 267                 }
 268         }
 269
 270         if (r->in.req.max_referral_level <= 2) {
 271                 max_referral_level = 2;
 272         }
 273         if (r->in.req.max_referral_level >= 3) {
 274                 max_referral_level = 3;
 275         }
 276
 277         r->out.resp = talloc_zero(r, struct dfs_referral_resp);
 278         if (r->out.resp == NULL) {
 279                 return NT_STATUS_NO_MEMORY;
 280         }
 281
 282         r->out.resp->path_consumed = strlen_m(pathnamep) * 2;
 283         r->out.resp->nb_referrals = junction->referral_count;
 284
 285         r->out.resp->header_flags = DFS_HEADER_FLAG_STORAGE_SVR;
 286         if (self_referral) {
 287                 r->out.resp->header_flags |= DFS_HEADER_FLAG_REFERAL_SVR;
 288         }
 289
 290         r->out.resp->referral_entries = talloc_zero_array(r,
 291                                 struct dfs_referral_type,
 292                                 r->out.resp->nb_referrals);
 293         if (r->out.resp->referral_entries == NULL) {
 294                 return NT_STATUS_NO_MEMORY;
 295         }
 296
 297         switch (max_referral_level) {
 298         case 2:
 299                 for(i=0; i < junction->referral_count; i++) {
 300                         struct referral *ref = &junction->referral_list[i];
 301                         TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
 302                         struct dfs_referral_type *t =
 303                                 &r->out.resp->referral_entries[i];
 304                         struct dfs_referral_v2 *v2 = &t->referral.v2;
 305
 306                         t->version = 2;
 307                         v2->size = VERSION2_REFERRAL_SIZE;
 308                         if (self_referral) {
 309                                 v2->server_type = DFS_SERVER_ROOT;
 310                         } else {
 311                                 v2->server_type = DFS_SERVER_NON_ROOT;
 312                         }
 313                         v2->entry_flags = 0;
 314                         v2->proximity = ref->proximity;
 315                         v2->ttl = ref->ttl;
 316                         v2->DFS_path = talloc_strdup(mem_ctx, pathnamep);
 317                         if (v2->DFS_path == NULL) {
 318                                 return NT_STATUS_NO_MEMORY;
 319                         }
 320                         v2->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
 321                         if (v2->DFS_alt_path == NULL) {
 322                                 return NT_STATUS_NO_MEMORY;
 323                         }
 324                         v2->netw_address = talloc_strdup(mem_ctx,
 325                                                          ref->alternate_path);
 326                         if (v2->netw_address == NULL) {
 327                                 return NT_STATUS_NO_MEMORY;
 328                         }
 329                 }
 330
 331                 break;
 332         case 3:
 333                 for(i=0; i < junction->referral_count; i++) {
 334                         struct referral *ref = &junction->referral_list[i];
 335                         TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
 336                         struct dfs_referral_type *t =
 337                                 &r->out.resp->referral_entries[i];
 338                         struct dfs_referral_v3 *v3 = &t->referral.v3;
 339                         struct dfs_normal_referral *r1 = &v3->referrals.r1;
 340
 341                         t->version = 3;
 342                         v3->size = VERSION3_REFERRAL_SIZE;
 343                         if (self_referral) {
 344                                 v3->server_type = DFS_SERVER_ROOT;
 345                         } else {
 346                                 v3->server_type = DFS_SERVER_NON_ROOT;
 347                         }
 348                         v3->entry_flags = 0;
 349                         v3->ttl = ref->ttl;
 350                         r1->DFS_path = talloc_strdup(mem_ctx, pathnamep);
 351                         if (r1->DFS_path == NULL) {
 352                                 return NT_STATUS_NO_MEMORY;
 353                         }
 354                         r1->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
 355                         if (r1->DFS_alt_path == NULL) {
 356                                 return NT_STATUS_NO_MEMORY;
 357                         }
 358                         r1->netw_address = talloc_strdup(mem_ctx,
 359                                                          ref->alternate_path);
 360                         if (r1->netw_address == NULL) {
 361                                 return NT_STATUS_NO_MEMORY;
 362                         }
 363                 }
 364                 break;
 365         default:
 366                 DEBUG(0,("Invalid dfs referral version: %d\n",
 367                         max_referral_level));
 368                 return NT_STATUS_INVALID_LEVEL;
 369         }
 370
 371         if (DEBUGLVL(10)) {
 372                 NDR_PRINT_OUT_DEBUG(dfs_GetDFSReferral, r);
 373         }
 374
 375         return NT_STATUS_OK;
 376 }
 377
 378 static NTSTATUS vfswrap_create_dfs_pathat(struct vfs_handle_struct *handle,
 379                                 struct files_struct *dirfsp,
 380                                 const struct smb_filename *smb_fname,
 381                                 const struct referral *reflist,
 382                                 size_t referral_count)
 383 {
 384         TALLOC_CTX *frame = talloc_stackframe();
 385         NTSTATUS status = NT_STATUS_NO_MEMORY;
 386         int ret;
 387         char *msdfs_link = NULL;
 388
 389         /* Form the msdfs_link contents */
 390         msdfs_link = msdfs_link_string(frame,
 391                                         reflist,
 392                                         referral_count);
 393         if (msdfs_link == NULL) {
 394                 goto out;
 395         }
 396
 397         ret = symlinkat(msdfs_link,
 398                         fsp_get_pathref_fd(dirfsp),
 399                         smb_fname->base_name);
 400         if (ret == 0) {
 401                 status = NT_STATUS_OK;
 402         } else {
 403                 status = map_nt_error_from_unix(errno);
 404         }
 405
 406   out:
 407
 408         TALLOC_FREE(frame);
 409         return status;
 410 }
 411
 412 /*
 413  * Read and return the contents of a DFS redirect given a
 414  * pathname. A caller can pass in NULL for ppreflist and
 415  * preferral_count but still determine if this was a
 416  * DFS redirect point by getting NT_STATUS_OK back
 417  * without incurring the overhead of reading and parsing
 418  * the referral contents.
 419  */
 420
 421 static NTSTATUS vfswrap_read_dfs_pathat(struct vfs_handle_struct *handle,
 422                                 TALLOC_CTX *mem_ctx,
 423                                 struct files_struct *dirfsp,
 424                                 struct smb_filename *smb_fname,
 425                                 struct referral **ppreflist,
 426                                 size_t *preferral_count)
 427 {
 428         NTSTATUS status = NT_STATUS_NO_MEMORY;
 429         size_t bufsize;
 430         char *link_target = NULL;
 431         int referral_len;
 432         bool ok;
 433 #if defined(HAVE_BROKEN_READLINK)
 434         char link_target_buf[PATH_MAX];
 435 #else
 436         char link_target_buf[7];
 437 #endif
 438         int ret;
 439
 440         if (is_named_stream(smb_fname)) {
 441                 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
 442                 goto err;
 443         }
 444
 445         if (ppreflist == NULL && preferral_count == NULL) {
 446                 /*
 447                  * We're only checking if this is a DFS
 448                  * redirect. We don't need to return data.
 449                  */
 450                 bufsize = sizeof(link_target_buf);
 451                 link_target = link_target_buf;
 452         } else {
 453                 bufsize = PATH_MAX;
 454                 link_target = talloc_array(mem_ctx, char, bufsize);
 455                 if (!link_target) {
 456                         goto err;
 457                 }
 458         }
 459
 460         referral_len = readlinkat(fsp_get_pathref_fd(dirfsp),
 461                                 smb_fname->base_name,
 462                                 link_target,
 463                                 bufsize - 1);
 464         if (referral_len == -1) {
 465                 if (errno == EINVAL) {
 466                         /*
 467                          * If the path isn't a link, readlinkat
 468                          * returns EINVAL. Allow the caller to
 469                          * detect this.
 470                          */
 471                         DBG_INFO("%s is not a link.\n", smb_fname->base_name);
 472                         status = NT_STATUS_OBJECT_TYPE_MISMATCH;
 473                 } else {
 474                         status = map_nt_error_from_unix(errno);
 475                         if (errno == ENOENT) {
 476                                 DBG_NOTICE("Error reading "
 477                                          "msdfs link %s: %s\n",
 478                                          smb_fname->base_name,
 479                                          strerror(errno));
 480                         } else {
 481                                 DBG_ERR("Error reading "
 482                                         "msdfs link %s: %s\n",
 483                                         smb_fname->base_name,
 484                                         strerror(errno));
 485                         }
 486                 }
 487                 goto err;
 488         }
 489         link_target[referral_len] = '\0';
 490
 491         DBG_INFO("%s -> %s\n",
 492                         smb_fname->base_name,
 493                         link_target);
 494
 495         if (!strnequal(link_target, "msdfs:", 6)) {
 496                 status = NT_STATUS_OBJECT_TYPE_MISMATCH;
 497                 goto err;
 498         }
 499
 500        ret = sys_fstatat(fsp_get_pathref_fd(dirfsp),
 501                          smb_fname->base_name,
 502                          &smb_fname->st,
 503                          AT_SYMLINK_NOFOLLOW,
 504                          lp_fake_directory_create_times(SNUM(handle->conn)));
 505         if (ret < 0) {
 506                 status = map_nt_error_from_unix(errno);
 507                 goto err;
 508         }
 509
 510         if (ppreflist == NULL && preferral_count == NULL) {
 511                 /* Early return for checking if this is a DFS link. */
 512                 return NT_STATUS_OK;
 513         }
 514
 515         ok = parse_msdfs_symlink(mem_ctx,
 516                         lp_msdfs_shuffle_referrals(SNUM(handle->conn)),
 517                         link_target,
 518                         ppreflist,
 519                         preferral_count);
 520
 521         if (ok) {
 522                 status = NT_STATUS_OK;
 523         } else {
 524                 status = NT_STATUS_NO_MEMORY;
 525         }
 526
 527   err:
 528
 529         if (link_target != link_target_buf) {
 530                 TALLOC_FREE(link_target);
 531         }
 532         return status;
 533 }
 534
 535 static NTSTATUS vfswrap_snap_check_path(struct vfs_handle_struct *handle,
 536                                         TALLOC_CTX *mem_ctx,
 537                                         const char *service_path,
 538                                         char **base_volume)
 539 {
 540         return NT_STATUS_NOT_SUPPORTED;
 541 }
 542
 543 static NTSTATUS vfswrap_snap_create(struct vfs_handle_struct *handle,
 544                                     TALLOC_CTX *mem_ctx,
 545                                     const char *base_volume,
 546                                     time_t *tstamp,
 547                                     bool rw,
 548                                     char **base_path,
 549                                     char **snap_path)
 550 {
 551         return NT_STATUS_NOT_SUPPORTED;
 552 }
 553
 554 static NTSTATUS vfswrap_snap_delete(struct vfs_handle_struct *handle,
 555                                     TALLOC_CTX *mem_ctx,
 556                                     char *base_path,
 557                                     char *snap_path)
 558 {
 559         return NT_STATUS_NOT_SUPPORTED;
 560 }
 561
 562 /* Directory operations */
 563
 564 static DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
 565                         files_struct *fsp,
 566                         const char *mask,
 567                         uint32_t attr)
 568 {
 569         DIR *result;
 570
 571         START_PROFILE(syscall_fdopendir);
 572         result = sys_fdopendir(fsp_get_io_fd(fsp));
 573         END_PROFILE(syscall_fdopendir);
 574         return result;
 575 }
 576
 577
 578 static struct dirent *vfswrap_readdir(vfs_handle_struct *handle,
 579                                       struct files_struct *dirfsp,
 580                                       DIR *dirp,
 581                                       SMB_STRUCT_STAT *sbuf)
 582 {
 583         struct dirent *result;
 584         bool fake_ctime = lp_fake_directory_create_times(SNUM(handle->conn));
 585         int flags = AT_SYMLINK_NOFOLLOW;
 586         SMB_STRUCT_STAT st;
 587         int ret;
 588
 589         START_PROFILE(syscall_readdir);
 590
 591         result = readdir(dirp);
 592         END_PROFILE(syscall_readdir);
 593
 594         if (sbuf == NULL) {
 595                 return result;
 596         }
 597         if (result == NULL) {
 598                 return NULL;
 599         }
 600
 601         /*
 602          * Default Posix readdir() does not give us stat info.
 603          * Set to invalid to indicate we didn't return this info.
 604          */
 605         SET_STAT_INVALID(*sbuf);
 606
 607         ret = sys_fstatat(dirfd(dirp),
 608                       result->d_name,
 609                       &st,
 610                       flags,
 611                       fake_ctime);
 612         if (ret != 0) {
 613                 return result;
 614         }
 615
 616         /*
 617          * As this is an optimization, ignore it if we stat'ed a
 618          * symlink for non-POSIX context. Make the caller do it again
 619          * as we don't know if they wanted the link info, or its
 620          * target info.
 621          */
 622         if (S_ISLNK(st.st_ex_mode) &&
 623             !(dirfsp->fsp_name->flags & SMB_FILENAME_POSIX_PATH))
 624         {
 625                 return result;
 626         }
 627         *sbuf = st;
 628
 629         return result;
 630 }
 631
 632 static NTSTATUS vfswrap_freaddir_attr(struct vfs_handle_struct *handle,
 633                                       struct files_struct *fsp,
 634                                       TALLOC_CTX *mem_ctx,
 635                                       struct readdir_attr_data **attr_data)
 636 {
 637         return NT_STATUS_NOT_SUPPORTED;
 638 }
 639
 640 static void vfswrap_seekdir(vfs_handle_struct *handle, DIR *dirp, long offset)
 641 {
 642         START_PROFILE(syscall_seekdir);
 643         seekdir(dirp, offset);
 644         END_PROFILE(syscall_seekdir);
 645 }
 646
 647 static long vfswrap_telldir(vfs_handle_struct *handle, DIR *dirp)
 648 {
 649         long result;
 650         START_PROFILE(syscall_telldir);
 651         result = telldir(dirp);
 652         END_PROFILE(syscall_telldir);
 653         return result;
 654 }
 655
 656 static void vfswrap_rewinddir(vfs_handle_struct *handle, DIR *dirp)
 657 {
 658         START_PROFILE(syscall_rewinddir);
 659         rewinddir(dirp);
 660         END_PROFILE(syscall_rewinddir);
 661 }
 662
 663 static int vfswrap_mkdirat(vfs_handle_struct *handle,
 664                         struct files_struct *dirfsp,
 665                         const struct smb_filename *smb_fname,
 666                         mode_t mode)
 667 {
 668         int result;
 669
 670         START_PROFILE(syscall_mkdirat);
 671
 672         result = mkdirat(fsp_get_pathref_fd(dirfsp), smb_fname->base_name, mode);
 673
 674         END_PROFILE(syscall_mkdirat);
 675         return result;
 676 }
 677
 678 static int vfswrap_closedir(vfs_handle_struct *handle, DIR *dirp)
 679 {
 680         int result;
 681
 682         START_PROFILE(syscall_closedir);
 683         result = closedir(dirp);
 684         END_PROFILE(syscall_closedir);
 685         return result;
 686 }
 687
 688 /* File operations */
 689
 690 static int vfswrap_openat(vfs_handle_struct *handle,
 691                           const struct files_struct *dirfsp,
 692                           const struct smb_filename *smb_fname,
 693                           files_struct *fsp,
 694                           int flags,
 695                           mode_t mode)
 696 {
 697         bool have_opath = false;
 698         bool became_root = false;
 699         int result;
 700
 701         START_PROFILE(syscall_openat);
 702
 703         if (is_named_stream(smb_fname)) {
 704                 errno = ENOENT;
 705                 result = -1;
 706                 goto out;
 707         }
 708
 709 #ifdef O_PATH
 710         have_opath = true;
 711         if (fsp->fsp_flags.is_pathref) {
 712                 flags |= O_PATH;
 713         }
 714 #endif
 715
 716         if (fsp->fsp_flags.is_pathref && !have_opath) {
 717                 become_root();
 718                 became_root = true;
 719         }
 720
 721         result = openat(fsp_get_pathref_fd(dirfsp),
 722                         smb_fname->base_name,
 723                         flags,
 724                         mode);
 725
 726         if (became_root) {
 727                 unbecome_root();
 728         }
 729
 730         fsp->fsp_flags.have_proc_fds = fsp->conn->have_proc_fds;
 731
 732 out:
 733         END_PROFILE(syscall_openat);
 734         return result;
 735 }
 736 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
 737                                     struct smb_request *req,
 738                                     struct smb_filename *smb_fname,
 739                                     uint32_t access_mask,
 740                                     uint32_t share_access,
 741                                     uint32_t create_disposition,
 742                                     uint32_t create_options,
 743                                     uint32_t file_attributes,
 744                                     uint32_t oplock_request,
 745                                     const struct smb2_lease *lease,
 746                                     uint64_t allocation_size,
 747                                     uint32_t private_flags,
 748                                     struct security_descriptor *sd,
 749                                     struct ea_list *ea_list,
 750                                     files_struct **result,
 751                                     int *pinfo,
 752                                     const struct smb2_create_blobs *in_context_blobs,
 753                                     struct smb2_create_blobs *out_context_blobs)
 754 {
 755         return create_file_default(handle->conn, req, smb_fname,
 756                                    access_mask, share_access,
 757                                    create_disposition, create_options,
 758                                    file_attributes, oplock_request, lease,
 759                                    allocation_size, private_flags,
 760                                    sd, ea_list, result,
 761                                    pinfo, in_context_blobs, out_context_blobs);
 762 }
 763
 764 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
 765 {
 766         int result;
 767
 768         START_PROFILE(syscall_close);
 769         result = fd_close_posix(fsp);
 770         END_PROFILE(syscall_close);
 771         return result;
 772 }
 773
 774 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
 775                         size_t n, off_t offset)
 776 {
 777         ssize_t result;
 778
 779 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 780         START_PROFILE_BYTES(syscall_pread, n);
 781         result = sys_pread_full(fsp_get_io_fd(fsp), data, n, offset);
 782         END_PROFILE_BYTES(syscall_pread);
 783
 784         if (result == -1 && errno == ESPIPE) {
 785                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 786                 result = sys_read(fsp_get_io_fd(fsp), data, n);
 787                 fh_set_pos(fsp->fh, 0);
 788         }
 789
 790 #else /* HAVE_PREAD */
 791         errno = ENOSYS;
 792         result = -1;
 793 #endif /* HAVE_PREAD */
 794
 795         return result;
 796 }
 797
 798 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
 799                         size_t n, off_t offset)
 800 {
 801         ssize_t result;
 802
 803 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 804         START_PROFILE_BYTES(syscall_pwrite, n);
 805         result = sys_pwrite_full(fsp_get_io_fd(fsp), data, n, offset);
 806         END_PROFILE_BYTES(syscall_pwrite);
 807
 808         if (result == -1 && errno == ESPIPE) {
 809                 /* Maintain the fiction that pipes can be sought on. */
 810                 result = sys_write(fsp_get_io_fd(fsp), data, n);
 811         }
 812
 813 #else /* HAVE_PWRITE */
 814         errno = ENOSYS;
 815         result = -1;
 816 #endif /* HAVE_PWRITE */
 817
 818         return result;
 819 }
 820
 821 struct vfswrap_pread_state {
 822         ssize_t ret;
 823         int fd;
 824         void *buf;
 825         size_t count;
 826         off_t offset;
 827
 828         struct vfs_aio_state vfs_aio_state;
 829         SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
 830 };
 831
 832 static void vfs_pread_do(void *private_data);
 833 static void vfs_pread_done(struct tevent_req *subreq);
 834 static int vfs_pread_state_destructor(struct vfswrap_pread_state *state);
 835
 836 static struct tevent_req *vfswrap_pread_send(struct vfs_handle_struct *handle,
 837                                              TALLOC_CTX *mem_ctx,
 838                                              struct tevent_context *ev,
 839                                              struct files_struct *fsp,
 840                                              void *data,
 841                                              size_t n, off_t offset)
 842 {
 843         struct tevent_req *req, *subreq;
 844         struct vfswrap_pread_state *state;
 845
 846         req = tevent_req_create(mem_ctx, &state, struct vfswrap_pread_state);
 847         if (req == NULL) {
 848                 return NULL;
 849         }
 850
 851         state->ret = -1;
 852         state->fd = fsp_get_io_fd(fsp);
 853         state->buf = data;
 854         state->count = n;
 855         state->offset = offset;
 856
 857         SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pread, profile_p,
 858                                      state->profile_bytes, n);
 859         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
 860
 861         subreq = pthreadpool_tevent_job_send(
 862                 state, ev, handle->conn->sconn->pool,
 863                 vfs_pread_do, state);
 864         if (tevent_req_nomem(subreq, req)) {
 865                 return tevent_req_post(req, ev);
 866         }
 867         tevent_req_set_callback(subreq, vfs_pread_done, req);
 868
 869         talloc_set_destructor(state, vfs_pread_state_destructor);
 870
 871         return req;
 872 }
 873
 874 static void vfs_pread_do(void *private_data)
 875 {
 876         struct vfswrap_pread_state *state = talloc_get_type_abort(
 877                 private_data, struct vfswrap_pread_state);
 878         struct timespec start_time;
 879         struct timespec end_time;
 880
 881         SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);
 882
 883         PROFILE_TIMESTAMP(&start_time);
 884
 885         state->ret = sys_pread_full(state->fd,
 886                                     state->buf,
 887                                     state->count,
 888                                     state->offset);
 889
 890         if (state->ret == -1) {
 891                 state->vfs_aio_state.error = errno;
 892         }
 893
 894         PROFILE_TIMESTAMP(&end_time);
 895
 896         state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);
 897
 898         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
 899 }
 900
 901 static int vfs_pread_state_destructor(struct vfswrap_pread_state *state)
 902 {
 903         return -1;
 904 }
 905
 906 static void vfs_pread_done(struct tevent_req *subreq)
 907 {
 908         struct tevent_req *req = tevent_req_callback_data(
 909                 subreq, struct tevent_req);
 910         struct vfswrap_pread_state *state = tevent_req_data(
 911                 req, struct vfswrap_pread_state);
 912         int ret;
 913
 914         ret = pthreadpool_tevent_job_recv(subreq);
 915         TALLOC_FREE(subreq);
 916         SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
 917         talloc_set_destructor(state, NULL);
 918         if (ret != 0) {
 919                 if (ret != EAGAIN) {
 920                         tevent_req_error(req, ret);
 921                         return;
 922                 }
 923                 /*
 924                  * If we get EAGAIN from pthreadpool_tevent_job_recv() this
 925                  * means the lower level pthreadpool failed to create a new
 926                  * thread. Fallback to sync processing in that case to allow
 927                  * some progress for the client.
 928                  */
 929                 vfs_pread_do(state);
 930         }
 931
 932         tevent_req_done(req);
 933 }
 934
 935 static ssize_t vfswrap_pread_recv(struct tevent_req *req,
 936                                   struct vfs_aio_state *vfs_aio_state)
 937 {
 938         struct vfswrap_pread_state *state = tevent_req_data(
 939                 req, struct vfswrap_pread_state);
 940
 941         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
 942                 return -1;
 943         }
 944
 945         *vfs_aio_state = state->vfs_aio_state;
 946         return state->ret;
 947 }
 948
 949 struct vfswrap_pwrite_state {
 950         ssize_t ret;
 951         int fd;
 952         const void *buf;
 953         size_t count;
 954         off_t offset;
 955
 956         struct vfs_aio_state vfs_aio_state;
 957         SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
 958 };
 959
 960 static void vfs_pwrite_do(void *private_data);
 961 static void vfs_pwrite_done(struct tevent_req *subreq);
 962 static int vfs_pwrite_state_destructor(struct vfswrap_pwrite_state *state);
 963
 964 static struct tevent_req *vfswrap_pwrite_send(struct vfs_handle_struct *handle,
 965                                               TALLOC_CTX *mem_ctx,
 966                                               struct tevent_context *ev,
 967                                               struct files_struct *fsp,
 968                                               const void *data,
 969                                               size_t n, off_t offset)
 970 {
 971         struct tevent_req *req, *subreq;
 972         struct vfswrap_pwrite_state *state;
 973
 974         req = tevent_req_create(mem_ctx, &state, struct vfswrap_pwrite_state);
 975         if (req == NULL) {
 976                 return NULL;
 977         }
 978
 979         state->ret = -1;
 980         state->fd = fsp_get_io_fd(fsp);
 981         state->buf = data;
 982         state->count = n;
 983         state->offset = offset;
 984
 985         SMBPROFILE_BYTES_ASYNC_START(syscall_asys_pwrite, profile_p,
 986                                      state->profile_bytes, n);
 987         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
 988
 989         subreq = pthreadpool_tevent_job_send(
 990                 state, ev, handle->conn->sconn->pool,
 991                 vfs_pwrite_do, state);
 992         if (tevent_req_nomem(subreq, req)) {
 993                 return tevent_req_post(req, ev);
 994         }
 995         tevent_req_set_callback(subreq, vfs_pwrite_done, req);
 996
 997         talloc_set_destructor(state, vfs_pwrite_state_destructor);
 998
 999         return req;
1000 }
1001
1002 static void vfs_pwrite_do(void *private_data)
1003 {
1004         struct vfswrap_pwrite_state *state = talloc_get_type_abort(
1005                 private_data, struct vfswrap_pwrite_state);
1006         struct timespec start_time;
1007         struct timespec end_time;
1008
1009         SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);
1010
1011         PROFILE_TIMESTAMP(&start_time);
1012
1013         state->ret = sys_pwrite_full(state->fd,
1014                                      state->buf,
1015                                      state->count,
1016                                      state->offset);
1017
1018         if (state->ret == -1) {
1019                 state->vfs_aio_state.error = errno;
1020         }
1021
1022         PROFILE_TIMESTAMP(&end_time);
1023
1024         state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);
1025
1026         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
1027 }
1028
1029 static int vfs_pwrite_state_destructor(struct vfswrap_pwrite_state *state)
1030 {
1031         return -1;
1032 }
1033
1034 static void vfs_pwrite_done(struct tevent_req *subreq)
1035 {
1036         struct tevent_req *req = tevent_req_callback_data(
1037                 subreq, struct tevent_req);
1038         struct vfswrap_pwrite_state *state = tevent_req_data(
1039                 req, struct vfswrap_pwrite_state);
1040         int ret;
1041
1042         ret = pthreadpool_tevent_job_recv(subreq);
1043         TALLOC_FREE(subreq);
1044         SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
1045         talloc_set_destructor(state, NULL);
1046         if (ret != 0) {
1047                 if (ret != EAGAIN) {
1048                         tevent_req_error(req, ret);
1049                         return;
1050                 }
1051                 /*
1052                  * If we get EAGAIN from pthreadpool_tevent_job_recv() this
1053                  * means the lower level pthreadpool failed to create a new
1054                  * thread. Fallback to sync processing in that case to allow
1055                  * some progress for the client.
1056                  */
1057                 vfs_pwrite_do(state);
1058         }
1059
1060         tevent_req_done(req);
1061 }
1062
1063 static ssize_t vfswrap_pwrite_recv(struct tevent_req *req,
1064                                    struct vfs_aio_state *vfs_aio_state)
1065 {
1066         struct vfswrap_pwrite_state *state = tevent_req_data(
1067                 req, struct vfswrap_pwrite_state);
1068
1069         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1070                 return -1;
1071         }
1072
1073         *vfs_aio_state = state->vfs_aio_state;
1074         return state->ret;
1075 }
1076
1077 struct vfswrap_fsync_state {
1078         ssize_t ret;
1079         int fd;
1080
1081         struct vfs_aio_state vfs_aio_state;
1082         SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
1083 };
1084
1085 static void vfs_fsync_do(void *private_data);
1086 static void vfs_fsync_done(struct tevent_req *subreq);
1087 static int vfs_fsync_state_destructor(struct vfswrap_fsync_state *state);
1088
1089 static struct tevent_req *vfswrap_fsync_send(struct vfs_handle_struct *handle,
1090                                              TALLOC_CTX *mem_ctx,
1091                                              struct tevent_context *ev,
1092                                              struct files_struct *fsp)
1093 {
1094         struct tevent_req *req, *subreq;
1095         struct vfswrap_fsync_state *state;
1096
1097         req = tevent_req_create(mem_ctx, &state, struct vfswrap_fsync_state);
1098         if (req == NULL) {
1099                 return NULL;
1100         }
1101
1102         state->ret = -1;
1103         state->fd = fsp_get_io_fd(fsp);
1104
1105         SMBPROFILE_BYTES_ASYNC_START(syscall_asys_fsync, profile_p,
1106                                      state->profile_bytes, 0);
1107         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
1108
1109         subreq = pthreadpool_tevent_job_send(
1110                 state, ev, handle->conn->sconn->pool, vfs_fsync_do, state);
1111         if (tevent_req_nomem(subreq, req)) {
1112                 return tevent_req_post(req, ev);
1113         }
1114         tevent_req_set_callback(subreq, vfs_fsync_done, req);
1115
1116         talloc_set_destructor(state, vfs_fsync_state_destructor);
1117
1118         return req;
1119 }
1120
1121 static void vfs_fsync_do(void *private_data)
1122 {
1123         struct vfswrap_fsync_state *state = talloc_get_type_abort(
1124                 private_data, struct vfswrap_fsync_state);
1125         struct timespec start_time;
1126         struct timespec end_time;
1127
1128         SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);
1129
1130         PROFILE_TIMESTAMP(&start_time);
1131
1132         do {
1133                 state->ret = fsync(state->fd);
1134         } while ((state->ret == -1) && (errno == EINTR));
1135
1136         if (state->ret == -1) {
1137                 state->vfs_aio_state.error = errno;
1138         }
1139
1140         PROFILE_TIMESTAMP(&end_time);
1141
1142         state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);
1143
1144         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
1145 }
1146
1147 static int vfs_fsync_state_destructor(struct vfswrap_fsync_state *state)
1148 {
1149         return -1;
1150 }
1151
1152 static void vfs_fsync_done(struct tevent_req *subreq)
1153 {
1154         struct tevent_req *req = tevent_req_callback_data(
1155                 subreq, struct tevent_req);
1156         struct vfswrap_fsync_state *state = tevent_req_data(
1157                 req, struct vfswrap_fsync_state);
1158         int ret;
1159
1160         ret = pthreadpool_tevent_job_recv(subreq);
1161         TALLOC_FREE(subreq);
1162         SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
1163         talloc_set_destructor(state, NULL);
1164         if (ret != 0) {
1165                 if (ret != EAGAIN) {
1166                         tevent_req_error(req, ret);
1167                         return;
1168                 }
1169                 /*
1170                  * If we get EAGAIN from pthreadpool_tevent_job_recv() this
1171                  * means the lower level pthreadpool failed to create a new
1172                  * thread. Fallback to sync processing in that case to allow
1173                  * some progress for the client.
1174                  */
1175                 vfs_fsync_do(state);
1176         }
1177
1178         tevent_req_done(req);
1179 }
1180
1181 static int vfswrap_fsync_recv(struct tevent_req *req,
1182                               struct vfs_aio_state *vfs_aio_state)
1183 {
1184         struct vfswrap_fsync_state *state = tevent_req_data(
1185                 req, struct vfswrap_fsync_state);
1186
1187         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1188                 return -1;
1189         }
1190
1191         *vfs_aio_state = state->vfs_aio_state;
1192         return state->ret;
1193 }
1194
1195 static off_t vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
1196 {
1197         off_t result = 0;
1198
1199         START_PROFILE(syscall_lseek);
1200
1201         result = lseek(fsp_get_io_fd(fsp), offset, whence);
1202         /*
1203          * We want to maintain the fiction that we can seek
1204          * on a fifo for file system purposes. This allows
1205          * people to set up UNIX fifo's that feed data to Windows
1206          * applications. JRA.
1207          */
1208
1209         if((result == -1) && (errno == ESPIPE)) {
1210                 result = 0;
1211                 errno = 0;
1212         }
1213
1214         END_PROFILE(syscall_lseek);
1215         return result;
1216 }
1217
1218 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
1219                         off_t offset, size_t n)
1220 {
1221         ssize_t result;
1222
1223         START_PROFILE_BYTES(syscall_sendfile, n);
1224         result = sys_sendfile(tofd, fsp_get_io_fd(fromfsp), hdr, offset, n);
1225         END_PROFILE_BYTES(syscall_sendfile);
1226         return result;
1227 }
1228
1229 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
1230                         int fromfd,
1231                         files_struct *tofsp,
1232                         off_t offset,
1233                         size_t n)
1234 {
1235         ssize_t result;
1236
1237         START_PROFILE_BYTES(syscall_recvfile, n);
1238         result = sys_recvfile(fromfd, fsp_get_io_fd(tofsp), offset, n);
1239         END_PROFILE_BYTES(syscall_recvfile);
1240         return result;
1241 }
1242
1243 static int vfswrap_renameat(vfs_handle_struct *handle,
1244                           files_struct *srcfsp,
1245                           const struct smb_filename *smb_fname_src,
1246                           files_struct *dstfsp,
1247                           const struct smb_filename *smb_fname_dst)
1248 {
1249         int result = -1;
1250
1251         START_PROFILE(syscall_renameat);
1252
1253         if (is_named_stream(smb_fname_src) || is_named_stream(smb_fname_dst)) {
1254                 errno = ENOENT;
1255                 goto out;
1256         }
1257
1258         result = renameat(fsp_get_pathref_fd(srcfsp),
1259                         smb_fname_src->base_name,
1260                         fsp_get_pathref_fd(dstfsp),
1261                         smb_fname_dst->base_name);
1262
1263  out:
1264         END_PROFILE(syscall_renameat);
1265         return result;
1266 }
1267
1268 static int vfswrap_stat(vfs_handle_struct *handle,
1269                         struct smb_filename *smb_fname)
1270 {
1271         int result = -1;
1272
1273         START_PROFILE(syscall_stat);
1274
1275         if (is_named_stream(smb_fname)) {
1276                 errno = ENOENT;
1277                 goto out;
1278         }
1279
1280         result = sys_stat(smb_fname->base_name, &smb_fname->st,
1281                           lp_fake_directory_create_times(SNUM(handle->conn)));
1282  out:
1283         END_PROFILE(syscall_stat);
1284         return result;
1285 }
1286
1287 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1288 {
1289         int result;
1290
1291         START_PROFILE(syscall_fstat);
1292         result = sys_fstat(fsp_get_pathref_fd(fsp),
1293                            sbuf, lp_fake_directory_create_times(SNUM(handle->conn)));
1294         END_PROFILE(syscall_fstat);
1295         return result;
1296 }
1297
1298 static int vfswrap_lstat(vfs_handle_struct *handle,
1299                          struct smb_filename *smb_fname)
1300 {
1301         int result = -1;
1302
1303         START_PROFILE(syscall_lstat);
1304
1305         if (is_named_stream(smb_fname)) {
1306                 errno = ENOENT;
1307                 goto out;
1308         }
1309
1310         result = sys_lstat(smb_fname->base_name, &smb_fname->st,
1311                            lp_fake_directory_create_times(SNUM(handle->conn)));
1312  out:
1313         END_PROFILE(syscall_lstat);
1314         return result;
1315 }
1316
1317 static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
1318                                        const char *name,
1319                                        enum vfs_translate_direction direction,
1320                                        TALLOC_CTX *mem_ctx,
1321                                        char **mapped_name)
1322 {
1323         return NT_STATUS_NONE_MAPPED;
1324 }
1325
1326 /**
1327  * Return allocated parent directory and basename of path
1328  *
1329  * Note: if requesting name, it is returned as talloc child of the
1330  * parent. Freeing the parent is thus sufficient to free both.
1331  */
1332 static NTSTATUS vfswrap_parent_pathname(struct vfs_handle_struct *handle,
1333                                         TALLOC_CTX *mem_ctx,
1334                                         const struct smb_filename *smb_fname_in,
1335                                         struct smb_filename **parent_dir_out,
1336                                         struct smb_filename **atname_out)
1337 {
1338         TALLOC_CTX *frame = talloc_stackframe();
1339         struct smb_filename *parent = NULL;
1340         struct smb_filename *name = NULL;
1341         char *p = NULL;
1342
1343         parent = cp_smb_filename(frame, smb_fname_in);
1344         if (parent == NULL) {
1345                 TALLOC_FREE(frame);
1346                 return NT_STATUS_NO_MEMORY;
1347         }
1348         TALLOC_FREE(parent->stream_name);
1349         SET_STAT_INVALID(parent->st);
1350
1351         p = strrchr_m(parent->base_name, '/'); /* Find final '/', if any */
1352         if (p == NULL) {
1353                 TALLOC_FREE(parent->base_name);
1354                 parent->base_name = talloc_strdup(parent, ".");
1355                 if (parent->base_name == NULL) {
1356                         TALLOC_FREE(frame);
1357                         return NT_STATUS_NO_MEMORY;
1358                 }
1359                 p = smb_fname_in->base_name;
1360         } else {
1361                 *p = '\0';
1362                 p++;
1363         }
1364
1365         if (atname_out == NULL) {
1366                 *parent_dir_out = talloc_move(mem_ctx, &parent);
1367                 TALLOC_FREE(frame);
1368                 return NT_STATUS_OK;
1369         }
1370
1371         name = cp_smb_filename(frame, smb_fname_in);
1372         if (name == NULL) {
1373                 TALLOC_FREE(frame);
1374                 return NT_STATUS_NO_MEMORY;
1375         }
1376         TALLOC_FREE(name->base_name);
1377
1378         name->base_name = talloc_strdup(name, p);
1379         if (name->base_name == NULL) {
1380                 TALLOC_FREE(frame);
1381                 return NT_STATUS_NO_MEMORY;
1382         }
1383
1384         *parent_dir_out = talloc_move(mem_ctx, &parent);
1385         *atname_out = talloc_move(*parent_dir_out, &name);
1386         TALLOC_FREE(frame);
1387         return NT_STATUS_OK;
1388 }
1389
1390 /*
1391  * Implement the default fsctl operation.
1392  */
1393 static bool vfswrap_logged_ioctl_message = false;
1394
1395 static NTSTATUS vfswrap_fsctl(struct vfs_handle_struct *handle,
1396                               struct files_struct *fsp,
1397                               TALLOC_CTX *ctx,
1398                               uint32_t function,
1399                               uint16_t req_flags, /* Needed for UNICODE ... */
1400                               const uint8_t *_in_data,
1401                               uint32_t in_len,
1402                               uint8_t **_out_data,
1403                               uint32_t max_out_len,
1404                               uint32_t *out_len)
1405 {
1406         const char *in_data = (const char *)_in_data;
1407         char **out_data = (char **)_out_data;
1408         NTSTATUS status;
1409
1410         switch (function) {
1411         case FSCTL_SET_SPARSE:
1412         {
1413                 bool set_sparse = true;
1414
1415                 if (in_len >= 1 && in_data[0] == 0) {
1416                         set_sparse = false;
1417                 }
1418
1419                 status = file_set_sparse(handle->conn, fsp, set_sparse);
1420
1421                 DEBUG(NT_STATUS_IS_OK(status) ? 10 : 9,
1422                       ("FSCTL_SET_SPARSE: fname[%s] set[%u] - %s\n",
1423                        smb_fname_str_dbg(fsp->fsp_name), set_sparse,
1424                        nt_errstr(status)));
1425
1426                 return status;
1427         }
1428
1429         case FSCTL_CREATE_OR_GET_OBJECT_ID:
1430         {
1431                 unsigned char objid[16];
1432                 char *return_data = NULL;
1433
1434                 /* This should return the object-id on this file.
1435                  * I think I'll make this be the inode+dev. JRA.
1436                  */
1437
1438                 DEBUG(10,("FSCTL_CREATE_OR_GET_OBJECT_ID: called on %s\n",
1439                           fsp_fnum_dbg(fsp)));
1440
1441                 *out_len = MIN(max_out_len, 64);
1442
1443                 /* Hmmm, will this cause problems if less data asked for? */
1444                 return_data = talloc_array(ctx, char, 64);
1445                 if (return_data == NULL) {
1446                         return NT_STATUS_NO_MEMORY;
1447                 }
1448
1449                 /* For backwards compatibility only store the dev/inode. */
1450                 push_file_id_16(return_data, &fsp->file_id);
1451                 memcpy(return_data+16,create_volume_objectid(fsp->conn,objid),16);
1452                 push_file_id_16(return_data+32, &fsp->file_id);
1453                 memset(return_data+48, 0, 16);
1454                 *out_data = return_data;
1455                 return NT_STATUS_OK;
1456         }
1457
1458         case FSCTL_GET_REPARSE_POINT:
1459         {
1460                 status = fsctl_get_reparse_point(
1461                         fsp, ctx, out_data, max_out_len, out_len);
1462                 return status;
1463         }
1464
1465         case FSCTL_SET_REPARSE_POINT:
1466         {
1467                 status = fsctl_set_reparse_point(fsp, ctx, _in_data, in_len);
1468                 return status;
1469         }
1470
1471         case FSCTL_DELETE_REPARSE_POINT:
1472         {
1473                 status = fsctl_del_reparse_point(fsp, ctx, _in_data, in_len);
1474                 return status;
1475         }
1476
1477         case FSCTL_GET_SHADOW_COPY_DATA:
1478         {
1479                 /*
1480                  * This is called to retrieve the number of Shadow Copies (a.k.a. snapshots)
1481                  * and return their volume names.  If max_data_count is 16, then it is just
1482                  * asking for the number of volumes and length of the combined names.
1483                  *
1484                  * pdata is the data allocated by our caller, but that uses
1485                  * total_data_count (which is 0 in our case) rather than max_data_count.
1486                  * Allocate the correct amount and return the pointer to let
1487                  * it be deallocated when we return.
1488                  */
1489                 struct shadow_copy_data *shadow_data = NULL;
1490                 bool labels = False;
1491                 uint32_t labels_data_count = 0;
1492                 uint32_t i;
1493                 char *cur_pdata = NULL;
1494
1495                 if (max_out_len < 16) {
1496                         DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) < 16 is invalid!\n",
1497                                 max_out_len));
1498                         return NT_STATUS_INVALID_PARAMETER;
1499                 }
1500
1501                 if (max_out_len > 16) {
1502                         labels = True;
1503                 }
1504
1505                 shadow_data = talloc_zero(ctx, struct shadow_copy_data);
1506                 if (shadow_data == NULL) {
1507                         DEBUG(0,("TALLOC_ZERO() failed!\n"));
1508                         return NT_STATUS_NO_MEMORY;
1509                 }
1510
1511                 /*
1512                  * Call the VFS routine to actually do the work.
1513                  */
1514                 if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
1515                         int log_lev = 0;
1516                         if (errno == 0) {
1517                                 /* broken module didn't set errno on error */
1518                                 status = NT_STATUS_UNSUCCESSFUL;
1519                         } else {
1520                                 status = map_nt_error_from_unix(errno);
1521                                 if (NT_STATUS_EQUAL(status,
1522                                                     NT_STATUS_NOT_SUPPORTED)) {
1523                                         log_lev = 5;
1524                                 }
1525                         }
1526                         DEBUG(log_lev, ("FSCTL_GET_SHADOW_COPY_DATA: "
1527                                         "connectpath %s, failed - %s.\n",
1528                                         fsp->conn->connectpath,
1529                                         nt_errstr(status)));
1530                         TALLOC_FREE(shadow_data);
1531                         return status;
1532                 }
1533
1534                 labels_data_count = (shadow_data->num_volumes * 2 *
1535                                         sizeof(SHADOW_COPY_LABEL)) + 2;
1536
1537                 if (!labels) {
1538                         *out_len = 16;
1539                 } else {
1540                         *out_len = 12 + labels_data_count;
1541                 }
1542
1543                 if (max_out_len < *out_len) {
1544                         DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) too small (%u) bytes needed!\n",
1545                                 max_out_len, *out_len));
1546                         TALLOC_FREE(shadow_data);
1547                         return NT_STATUS_BUFFER_TOO_SMALL;
1548                 }
1549
1550                 cur_pdata = talloc_zero_array(ctx, char, *out_len);
1551                 if (cur_pdata == NULL) {
1552                         TALLOC_FREE(shadow_data);
1553                         return NT_STATUS_NO_MEMORY;
1554                 }
1555
1556                 *out_data = cur_pdata;
1557
1558                 /* num_volumes 4 bytes */
1559                 SIVAL(cur_pdata, 0, shadow_data->num_volumes);
1560
1561                 if (labels) {
1562                         /* num_labels 4 bytes */
1563                         SIVAL(cur_pdata, 4, shadow_data->num_volumes);
1564                 }
1565
1566                 /* needed_data_count 4 bytes */
1567                 SIVAL(cur_pdata, 8, labels_data_count);
1568
1569                 cur_pdata += 12;
1570
1571                 DEBUG(10,("FSCTL_GET_SHADOW_COPY_DATA: %u volumes for path[%s].\n",
1572                           shadow_data->num_volumes, fsp_str_dbg(fsp)));
1573                 if (labels && shadow_data->labels) {
1574                         for (i=0; i<shadow_data->num_volumes; i++) {
1575                                 size_t len = 0;
1576                                 status = srvstr_push(cur_pdata, req_flags,
1577                                             cur_pdata, shadow_data->labels[i],
1578                                             2 * sizeof(SHADOW_COPY_LABEL),
1579                                             STR_UNICODE|STR_TERMINATE, &len);
1580                                 if (!NT_STATUS_IS_OK(status)) {
1581                                         TALLOC_FREE(*out_data);
1582                                         TALLOC_FREE(shadow_data);
1583                                         return status;
1584                                 }
1585                                 cur_pdata += 2 * sizeof(SHADOW_COPY_LABEL);
1586                                 DEBUGADD(10,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
1587                         }
1588                 }
1589
1590                 TALLOC_FREE(shadow_data);
1591
1592                 return NT_STATUS_OK;
1593         }
1594
1595         case FSCTL_FIND_FILES_BY_SID:
1596         {
1597                 /* pretend this succeeded -
1598                  *
1599                  * we have to send back a list with all files owned by this SID
1600                  *
1601                  * but I have to check that --metze
1602                  */
1603                 ssize_t ret;
1604                 struct dom_sid sid;
1605                 struct dom_sid_buf buf;
1606                 uid_t uid;
1607                 size_t sid_len;
1608
1609                 DEBUG(10, ("FSCTL_FIND_FILES_BY_SID: called on %s\n",
1610                            fsp_fnum_dbg(fsp)));
1611
1612                 if (in_len < 8) {
1613                         /* NT_STATUS_BUFFER_TOO_SMALL maybe? */
1614                         return NT_STATUS_INVALID_PARAMETER;
1615                 }
1616
1617                 sid_len = MIN(in_len - 4,SID_MAX_SIZE);
1618
1619                 /* unknown 4 bytes: this is not the length of the sid :-(  */
1620                 /*unknown = IVAL(pdata,0);*/
1621
1622                 ret = sid_parse(_in_data + 4, sid_len, &sid);
1623                 if (ret == -1) {
1624                         return NT_STATUS_INVALID_PARAMETER;
1625                 }
1626                 DEBUGADD(10, ("for SID: %s\n",
1627                               dom_sid_str_buf(&sid, &buf)));
1628
1629                 if (!sid_to_uid(&sid, &uid)) {
1630                         DEBUG(0,("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
1631                                  dom_sid_str_buf(&sid, &buf),
1632                                  (unsigned long)sid_len));
1633                         uid = (-1);
1634                 }
1635
1636                 /* we can take a look at the find source :-)
1637                  *
1638                  * find ./ -uid $uid  -name '*'   is what we need here
1639                  *
1640                  *
1641                  * and send 4bytes len and then NULL terminated unicode strings
1642                  * for each file
1643                  *
1644                  * but I don't know how to deal with the paged results
1645                  * (maybe we can hang the result anywhere in the fsp struct)
1646                  *
1647                  * but I don't know how to deal with the paged results
1648                  * (maybe we can hang the result anywhere in the fsp struct)
1649                  *
1650                  * we don't send all files at once
1651                  * and at the next we should *not* start from the beginning,
1652                  * so we have to cache the result
1653                  *
1654                  * --metze
1655                  */
1656
1657                 /* this works for now... */
1658                 return NT_STATUS_OK;
1659         }
1660
1661         case FSCTL_QUERY_ALLOCATED_RANGES:
1662         {
1663                 /* FIXME: This is just a dummy reply, telling that all of the
1664                  * file is allocated. MKS cp needs that.
1665                  * Adding the real allocated ranges via FIEMAP on Linux
1666                  * and SEEK_DATA/SEEK_HOLE on Solaris is needed to make
1667                  * this FSCTL correct for sparse files.
1668                  */
1669                 uint64_t offset, length;
1670                 char *out_data_tmp = NULL;
1671
1672                 if (in_len != 16) {
1673                         DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: data_count(%u) != 16 is invalid!\n",
1674                                 in_len));
1675                         return NT_STATUS_INVALID_PARAMETER;
1676                 }
1677
1678                 if (max_out_len < 16) {
1679                         DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: max_out_len (%u) < 16 is invalid!\n",
1680                                 max_out_len));
1681                         return NT_STATUS_INVALID_PARAMETER;
1682                 }
1683
1684                 offset = BVAL(in_data,0);
1685                 length = BVAL(in_data,8);
1686
1687                 if (offset + length < offset) {
1688                         /* No 64-bit integer wrap. */
1689                         return NT_STATUS_INVALID_PARAMETER;
1690                 }
1691
1692                 /* Shouldn't this be SMB_VFS_STAT ... ? */
1693                 status = vfs_stat_fsp(fsp);
1694                 if (!NT_STATUS_IS_OK(status)) {
1695                         return status;
1696                 }
1697
1698                 *out_len = 16;
1699                 out_data_tmp = talloc_array(ctx, char, *out_len);
1700                 if (out_data_tmp == NULL) {
1701                         DEBUG(10, ("unable to allocate memory for response\n"));
1702                         return NT_STATUS_NO_MEMORY;
1703                 }
1704
1705                 if (offset > fsp->fsp_name->st.st_ex_size ||
1706                                 fsp->fsp_name->st.st_ex_size == 0 ||
1707                                 length == 0) {
1708                         memset(out_data_tmp, 0, *out_len);
1709                 } else {
1710                         uint64_t end = offset + length;
1711                         end = MIN(end, fsp->fsp_name->st.st_ex_size);
1712                         SBVAL(out_data_tmp, 0, 0);
1713                         SBVAL(out_data_tmp, 8, end);
1714                 }
1715
1716                 *out_data = out_data_tmp;
1717
1718                 return NT_STATUS_OK;
1719         }
1720
1721         case FSCTL_IS_VOLUME_DIRTY:
1722         {
1723                 DEBUG(10,("FSCTL_IS_VOLUME_DIRTY: called on %s "
1724                           "(but remotely not supported)\n", fsp_fnum_dbg(fsp)));
1725                 /*
1726                  * http://msdn.microsoft.com/en-us/library/cc232128%28PROT.10%29.aspx
1727                  * says we have to respond with NT_STATUS_INVALID_PARAMETER
1728                  */
1729                 return NT_STATUS_INVALID_PARAMETER;
1730         }
1731
1732         default:
1733                 /*
1734                  * Only print once ... unfortunately there could be lots of
1735                  * different FSCTLs that are called.
1736                  */
1737                 if (!vfswrap_logged_ioctl_message) {
1738                         vfswrap_logged_ioctl_message = true;
1739                         DEBUG(2, ("%s (0x%x): Currently not implemented.\n",
1740                         __func__, function));
1741                 }
1742         }
1743
1744         return NT_STATUS_NOT_SUPPORTED;
1745 }
1746
1747 static bool vfswrap_is_offline(struct connection_struct *conn,
1748                                const struct smb_filename *fname);
1749
1750 struct vfswrap_get_dos_attributes_state {
1751         struct vfs_aio_state aio_state;
1752         connection_struct *conn;
1753         TALLOC_CTX *mem_ctx;
1754         struct tevent_context *ev;
1755         files_struct *dir_fsp;
1756         struct smb_filename *smb_fname;
1757         uint32_t dosmode;
1758         bool as_root;
1759 };
1760
1761 static void vfswrap_get_dos_attributes_getxattr_done(struct tevent_req *subreq);
1762
1763 static struct tevent_req *vfswrap_get_dos_attributes_send(
1764                         TALLOC_CTX *mem_ctx,
1765                         struct tevent_context *ev,
1766                         struct vfs_handle_struct *handle,
1767                         files_struct *dir_fsp,
1768                         struct smb_filename *smb_fname)
1769 {
1770         struct tevent_req *req = NULL;
1771         struct tevent_req *subreq = NULL;
1772         struct vfswrap_get_dos_attributes_state *state = NULL;
1773
1774         req = tevent_req_create(mem_ctx, &state,
1775                                 struct vfswrap_get_dos_attributes_state);
1776         if (req == NULL) {
1777                 return NULL;
1778         }
1779
1780         *state = (struct vfswrap_get_dos_attributes_state) {
1781                 .conn = dir_fsp->conn,
1782                 .mem_ctx = mem_ctx,
1783                 .ev = ev,
1784                 .dir_fsp = dir_fsp,
1785                 .smb_fname = smb_fname,
1786         };
1787
1788         subreq = SMB_VFS_GETXATTRAT_SEND(state,
1789                                          ev,
1790                                          dir_fsp,
1791                                          smb_fname,
1792                                          SAMBA_XATTR_DOS_ATTRIB,
1793                                          sizeof(fstring));
1794         if (tevent_req_nomem(subreq, req)) {
1795                 return tevent_req_post(req, ev);
1796         }
1797         tevent_req_set_callback(subreq,
1798                                 vfswrap_get_dos_attributes_getxattr_done,
1799                                 req);
1800
1801         return req;
1802 }
1803
1804 static void vfswrap_get_dos_attributes_getxattr_done(struct tevent_req *subreq)
1805 {
1806         struct tevent_req *req =
1807                 tevent_req_callback_data(subreq,
1808                 struct tevent_req);
1809         struct vfswrap_get_dos_attributes_state *state =
1810                 tevent_req_data(req,
1811                 struct vfswrap_get_dos_attributes_state);
1812         ssize_t xattr_size;
1813         DATA_BLOB blob = {0};
1814         char *path = NULL;
1815         char *tofree = NULL;
1816         char pathbuf[PATH_MAX+1];
1817         ssize_t pathlen;
1818         struct smb_filename smb_fname;
1819         bool offline;
1820         NTSTATUS status;
1821
1822         xattr_size = SMB_VFS_GETXATTRAT_RECV(subreq,
1823                                              &state->aio_state,
1824                                              state,
1825                                              &blob.data);
1826         TALLOC_FREE(subreq);
1827         if (xattr_size == -1) {
1828                 status = map_nt_error_from_unix(state->aio_state.error);
1829
1830                 if (state->as_root) {
1831                         tevent_req_nterror(req, status);
1832                         return;
1833                 }
1834                 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1835                         tevent_req_nterror(req, status);
1836                         return;
1837                 }
1838
1839                 state->as_root = true;
1840
1841                 become_root();
1842                 subreq = SMB_VFS_GETXATTRAT_SEND(state,
1843                                                  state->ev,
1844                                                  state->dir_fsp,
1845                                                  state->smb_fname,
1846                                                  SAMBA_XATTR_DOS_ATTRIB,
1847                                                  sizeof(fstring));
1848                 unbecome_root();
1849                 if (tevent_req_nomem(subreq, req)) {
1850                         return;
1851                 }
1852                 tevent_req_set_callback(subreq,
1853                                         vfswrap_get_dos_attributes_getxattr_done,
1854                                         req);
1855                 return;
1856         }
1857
1858         blob.length = xattr_size;
1859
1860         status = parse_dos_attribute_blob(state->smb_fname,
1861                                           blob,
1862                                           &state->dosmode);
1863         if (!NT_STATUS_IS_OK(status)) {
1864                 tevent_req_nterror(req, status);
1865                 return;
1866         }
1867
1868         pathlen = full_path_tos(state->dir_fsp->fsp_name->base_name,
1869                                 state->smb_fname->base_name,
1870                                 pathbuf,
1871                                 sizeof(pathbuf),
1872                                 &path,
1873                                 &tofree);
1874         if (pathlen == -1) {
1875                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
1876                 return;
1877         }
1878
1879         smb_fname = (struct smb_filename) {
1880                 .base_name = path,
1881                 .st = state->smb_fname->st,
1882                 .flags = state->smb_fname->flags,
1883                 .twrp = state->smb_fname->twrp,
1884         };
1885
1886         offline = vfswrap_is_offline(state->conn, &smb_fname);
1887         if (offline) {
1888                 state->dosmode |= FILE_ATTRIBUTE_OFFLINE;
1889         }
1890         TALLOC_FREE(tofree);
1891
1892         tevent_req_done(req);
1893         return;
1894 }
1895
1896 static NTSTATUS vfswrap_get_dos_attributes_recv(struct tevent_req *req,
1897                                                 struct vfs_aio_state *aio_state,
1898                                                 uint32_t *dosmode)
1899 {
1900         struct vfswrap_get_dos_attributes_state *state =
1901                 tevent_req_data(req,
1902                 struct vfswrap_get_dos_attributes_state);
1903         NTSTATUS status;
1904
1905         if (tevent_req_is_nterror(req, &status)) {
1906                 tevent_req_received(req);
1907                 return status;
1908         }
1909
1910         *aio_state = state->aio_state;
1911         *dosmode = state->dosmode;
1912         tevent_req_received(req);
1913         return NT_STATUS_OK;
1914 }
1915
1916 static NTSTATUS vfswrap_fget_dos_attributes(struct vfs_handle_struct *handle,
1917                                             struct files_struct *fsp,
1918                                             uint32_t *dosmode)
1919 {
1920         bool offline;
1921
1922         offline = vfswrap_is_offline(handle->conn, fsp->fsp_name);
1923         if (offline) {
1924                 *dosmode |= FILE_ATTRIBUTE_OFFLINE;
1925         }
1926
1927         return fget_ea_dos_attribute(fsp, dosmode);
1928 }
1929
1930 static NTSTATUS vfswrap_fset_dos_attributes(struct vfs_handle_struct *handle,
1931                                             struct files_struct *fsp,
1932                                             uint32_t dosmode)
1933 {
1934         return set_ea_dos_attribute(handle->conn, fsp->fsp_name, dosmode);
1935 }
1936
1937 static struct vfs_offload_ctx *vfswrap_offload_ctx;
1938
1939 struct vfswrap_offload_read_state {
1940         DATA_BLOB token;
1941 };
1942
1943 static struct tevent_req *vfswrap_offload_read_send(
1944         TALLOC_CTX *mem_ctx,
1945         struct tevent_context *ev,
1946         struct vfs_handle_struct *handle,
1947         struct files_struct *fsp,
1948         uint32_t fsctl,
1949         uint32_t ttl,
1950         off_t offset,
1951         size_t to_copy)
1952 {
1953         struct tevent_req *req = NULL;
1954         struct vfswrap_offload_read_state *state = NULL;
1955         NTSTATUS status;
1956
1957         req = tevent_req_create(mem_ctx, &state,
1958                                 struct vfswrap_offload_read_state);
1959         if (req == NULL) {
1960                 return NULL;
1961         }
1962
1963         status = vfs_offload_token_ctx_init(fsp->conn->sconn->client,
1964                                             &vfswrap_offload_ctx);
1965         if (tevent_req_nterror(req, status)) {
1966                 return tevent_req_post(req, ev);
1967         }
1968
1969         if (fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
1970                 tevent_req_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST);
1971                 return tevent_req_post(req, ev);
1972         }
1973
1974         status = vfs_offload_token_create_blob(state, fsp, fsctl,
1975                                                &state->token);
1976         if (tevent_req_nterror(req, status)) {
1977                 return tevent_req_post(req, ev);
1978         }
1979
1980         status = vfs_offload_token_db_store_fsp(vfswrap_offload_ctx, fsp,
1981                                                 &state->token);
1982         if (tevent_req_nterror(req, status)) {
1983                 return tevent_req_post(req, ev);
1984         }
1985
1986         tevent_req_done(req);
1987         return tevent_req_post(req, ev);
1988 }
1989
1990 static NTSTATUS vfswrap_offload_read_recv(struct tevent_req *req,
1991                                           struct vfs_handle_struct *handle,
1992                                           TALLOC_CTX *mem_ctx,
1993                                           DATA_BLOB *token)
1994 {
1995         struct vfswrap_offload_read_state *state = tevent_req_data(
1996                 req, struct vfswrap_offload_read_state);
1997         NTSTATUS status;
1998
1999         if (tevent_req_is_nterror(req, &status)) {
2000                 tevent_req_received(req);
2001                 return status;
2002         }
2003
2004         token->length = state->token.length;
2005         token->data = talloc_move(mem_ctx, &state->token.data);
2006
2007         tevent_req_received(req);
2008         return NT_STATUS_OK;
2009 }
2010
2011 struct vfswrap_offload_write_state {
2012         uint8_t *buf;
2013         bool read_lck_locked;
2014         bool write_lck_locked;
2015         DATA_BLOB *token;
2016         struct tevent_context *src_ev;
2017         struct files_struct *src_fsp;
2018         off_t src_off;
2019         struct tevent_context *dst_ev;
2020         struct files_struct *dst_fsp;
2021         off_t dst_off;
2022         off_t to_copy;
2023         off_t remaining;
2024         off_t copied;
2025         size_t next_io_size;
2026 };
2027
2028 static void vfswrap_offload_write_cleanup(struct tevent_req *req,
2029                                           enum tevent_req_state req_state)
2030 {
2031         struct vfswrap_offload_write_state *state = tevent_req_data(
2032                 req, struct vfswrap_offload_write_state);
2033         bool ok;
2034
2035         if (state->dst_fsp == NULL) {
2036                 return;
2037         }
2038
2039         ok = change_to_user_and_service_by_fsp(state->dst_fsp);
2040         SMB_ASSERT(ok);
2041         state->dst_fsp = NULL;
2042 }
2043
2044 static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req);
2045 static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req);
2046
2047 static struct tevent_req *vfswrap_offload_write_send(
2048         struct vfs_handle_struct *handle,
2049         TALLOC_CTX *mem_ctx,
2050         struct tevent_context *ev,
2051         uint32_t fsctl,
2052         DATA_BLOB *token,
2053         off_t transfer_offset,
2054         struct files_struct *dest_fsp,
2055         off_t dest_off,
2056         off_t to_copy)
2057 {
2058         struct tevent_req *req;
2059         struct vfswrap_offload_write_state *state = NULL;
2060         /* off_t is signed! */
2061         off_t max_offset = INT64_MAX - to_copy;
2062         size_t num = MIN(to_copy, COPYCHUNK_MAX_TOTAL_LEN);
2063         files_struct *src_fsp = NULL;
2064         NTSTATUS status;
2065         bool ok;
2066
2067         req = tevent_req_create(mem_ctx, &state,
2068                                 struct vfswrap_offload_write_state);
2069         if (req == NULL) {
2070                 return NULL;
2071         }
2072
2073         *state = (struct vfswrap_offload_write_state) {
2074                 .token = token,
2075                 .src_off = transfer_offset,
2076                 .dst_ev = ev,
2077                 .dst_fsp = dest_fsp,
2078                 .dst_off = dest_off,
2079                 .to_copy = to_copy,
2080                 .remaining = to_copy,
2081         };
2082
2083         tevent_req_set_cleanup_fn(req, vfswrap_offload_write_cleanup);
2084
2085         switch (fsctl) {
2086         case FSCTL_SRV_COPYCHUNK:
2087         case FSCTL_SRV_COPYCHUNK_WRITE:
2088                 break;
2089
2090         case FSCTL_OFFLOAD_WRITE:
2091                 tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
2092                 return tevent_req_post(req, ev);
2093
2094         case FSCTL_DUP_EXTENTS_TO_FILE:
2095                 DBG_DEBUG("COW clones not supported by vfs_default\n");
2096                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2097                 return tevent_req_post(req, ev);
2098
2099         default:
2100                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
2101                 return tevent_req_post(req, ev);
2102         }
2103
2104         /*
2105          * From here on we assume a copy-chunk fsctl
2106          */
2107
2108         if (to_copy == 0) {
2109                 tevent_req_done(req);
2110                 return tevent_req_post(req, ev);
2111         }
2112
2113         if (state->src_off > max_offset) {
2114                 /*
2115                  * Protect integer checks below.
2116                  */
2117                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2118                 return tevent_req_post(req, ev);
2119         }
2120         if (state->src_off < 0) {
2121                 /*
2122                  * Protect integer checks below.
2123                  */
2124                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2125                 return tevent_req_post(req, ev);
2126         }
2127         if (state->dst_off > max_offset) {
2128                 /*
2129                  * Protect integer checks below.
2130                  */
2131                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2132                 return tevent_req_post(req, ev);
2133         }
2134         if (state->dst_off < 0) {
2135                 /*
2136                  * Protect integer checks below.
2137                  */
2138                 tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
2139                 return tevent_req_post(req, ev);
2140         }
2141
2142         status = vfs_offload_token_db_fetch_fsp(vfswrap_offload_ctx,
2143                                                 token, &src_fsp);
2144         if (tevent_req_nterror(req, status)) {
2145                 return tevent_req_post(req, ev);
2146         }
2147
2148         DBG_DEBUG("server side copy chunk of length %" PRIu64 "\n", to_copy);
2149
2150         status = vfs_offload_token_check_handles(fsctl, src_fsp, dest_fsp);
2151         if (!NT_STATUS_IS_OK(status)) {
2152                 tevent_req_nterror(req, status);
2153                 return tevent_req_post(req, ev);
2154         }
2155
2156         ok = change_to_user_and_service_by_fsp(src_fsp);
2157         if (!ok) {
2158                 tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED);
2159                 return tevent_req_post(req, ev);
2160         }
2161
2162         state->src_ev = src_fsp->conn->sconn->ev_ctx;
2163         state->src_fsp = src_fsp;
2164
2165         status = vfs_stat_fsp(src_fsp);
2166         if (tevent_req_nterror(req, status)) {
2167                 return tevent_req_post(req, ev);
2168         }
2169
2170         if (src_fsp->fsp_name->st.st_ex_size < state->src_off + to_copy) {
2171                 /*
2172                  * [MS-SMB2] 3.3.5.15.6 Handling a Server-Side Data Copy Request
2173                  *   If the SourceOffset or SourceOffset + Length extends beyond
2174                  *   the end of file, the server SHOULD<240> treat this as a
2175                  *   STATUS_END_OF_FILE error.
2176                  * ...
2177                  *   <240> Section 3.3.5.15.6: Windows servers will return
2178                  *   STATUS_INVALID_VIEW_SIZE instead of STATUS_END_OF_FILE.
2179                  */
2180                 tevent_req_nterror(req, NT_STATUS_INVALID_VIEW_SIZE);
2181                 return tevent_req_post(req, ev);
2182         }
2183
2184         status = vfswrap_offload_copy_file_range(req);
2185         if (NT_STATUS_IS_OK(status)) {
2186                 tevent_req_done(req);
2187                 return tevent_req_post(req, ev);
2188         }
2189         if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
2190                 tevent_req_nterror(req, status);
2191                 return tevent_req_post(req, ev);
2192         }
2193
2194         state->buf = talloc_array(state, uint8_t, num);
2195         if (tevent_req_nomem(state->buf, req)) {
2196                 return tevent_req_post(req, ev);
2197         }
2198
2199         status = vfswrap_offload_write_loop(req);
2200         if (!NT_STATUS_IS_OK(status)) {
2201                 tevent_req_nterror(req, status);
2202                 return tevent_req_post(req, ev);
2203         }
2204
2205         return req;
2206 }
2207
2208 static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req)
2209 {
2210         struct vfswrap_offload_write_state *state = tevent_req_data(
2211                 req, struct vfswrap_offload_write_state);
2212         struct lock_struct lck;
2213         ssize_t nwritten;
2214         NTSTATUS status;
2215         bool same_file;
2216         bool ok;
2217         static bool try_copy_file_range = true;
2218
2219         if (!try_copy_file_range) {
2220                 return NT_STATUS_MORE_PROCESSING_REQUIRED;
2221         }
2222
2223         same_file = file_id_equal(&state->src_fsp->file_id,
2224                                   &state->dst_fsp->file_id);
2225         if (same_file &&
2226             sys_io_ranges_overlap(state->remaining,
2227                                   state->src_off,
2228                                   state->remaining,
2229                                   state->dst_off))
2230         {
2231                 return NT_STATUS_MORE_PROCESSING_REQUIRED;
2232         }
2233
2234         if (is_named_stream(state->src_fsp->fsp_name) ||
2235             is_named_stream(state->dst_fsp->fsp_name))
2236         {
2237                 return NT_STATUS_MORE_PROCESSING_REQUIRED;
2238         }
2239
2240         init_strict_lock_struct(state->src_fsp,
2241                                 state->src_fsp->op->global->open_persistent_id,
2242                                 state->src_off,
2243                                 state->remaining,
2244                                 READ_LOCK,
2245                                 &lck);
2246
2247         ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
2248                                  state->src_fsp,
2249                                  &lck);
2250         if (!ok) {
2251                 return NT_STATUS_FILE_LOCK_CONFLICT;
2252         }
2253
2254         ok = change_to_user_and_service_by_fsp(state->dst_fsp);
2255         if (!ok) {
2256                 return NT_STATUS_INTERNAL_ERROR;
2257         }
2258
2259         init_strict_lock_struct(state->dst_fsp,
2260                                 state->dst_fsp->op->global->open_persistent_id,
2261                                 state->dst_off,
2262                                 state->remaining,
2263                                 WRITE_LOCK,
2264                                 &lck);
2265
2266         ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
2267                                        state->dst_fsp,
2268                                        &lck);
2269         if (!ok) {
2270                 return NT_STATUS_FILE_LOCK_CONFLICT;
2271         }
2272
2273         while (state->remaining > 0) {
2274                 nwritten = copy_file_range(fsp_get_io_fd(state->src_fsp),
2275                                            &state->src_off,
2276                                            fsp_get_io_fd(state->dst_fsp),
2277                                            &state->dst_off,
2278                                            state->remaining,
2279                                            0);
2280                 if (nwritten == -1) {
2281                         DBG_DEBUG("copy_file_range src [%s]:[%jd] dst [%s]:[%jd] "
2282                                   "n [%jd] failed: %s\n",
2283                                   fsp_str_dbg(state->src_fsp),
2284                                   (intmax_t)state->src_off,
2285                                   fsp_str_dbg(state->dst_fsp),
2286                                   (intmax_t)state->dst_off,
2287                                   (intmax_t)state->remaining,
2288                                   strerror(errno));
2289                         switch (errno) {
2290                         case EOPNOTSUPP:
2291                         case ENOSYS:
2292                                 try_copy_file_range = false;
2293                                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
2294                                 break;
2295                         case EXDEV:
2296                                 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
2297                                 break;
2298                         default:
2299                                 status = map_nt_error_from_unix(errno);
2300                                 if (NT_STATUS_EQUAL(
2301                                             status,
2302                                             NT_STATUS_MORE_PROCESSING_REQUIRED))
2303                                 {
2304                                         /* Avoid triggering the fallback */
2305                                         status = NT_STATUS_INTERNAL_ERROR;
2306                                 }
2307                                 break;
2308                         }
2309                         return status;
2310                 }
2311
2312                 if (state->remaining < nwritten) {
2313                         DBG_DEBUG("copy_file_range src [%s] dst [%s] "
2314                                   "n [%jd] remaining [%jd]\n",
2315                                   fsp_str_dbg(state->src_fsp),
2316                                   fsp_str_dbg(state->dst_fsp),
2317                                   (intmax_t)nwritten,
2318                                   (intmax_t)state->remaining);
2319                         return NT_STATUS_INTERNAL_ERROR;
2320                 }
2321
2322                 if (nwritten == 0) {
2323                         break;
2324                 }
2325                 state->copied += nwritten;
2326                 state->remaining -= nwritten;
2327         }
2328
2329         /*
2330          * Tell the req cleanup function there's no need to call
2331          * change_to_user_and_service_by_fsp() on the dst handle.
2332          */
2333         state->dst_fsp = NULL;
2334         return NT_STATUS_OK;
2335 }
2336
2337 static void vfswrap_offload_write_read_done(struct tevent_req *subreq);
2338
2339 static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req)
2340 {
2341         struct vfswrap_offload_write_state *state = tevent_req_data(
2342                 req, struct vfswrap_offload_write_state);
2343         struct tevent_req *subreq = NULL;
2344         struct lock_struct read_lck;
2345         bool ok;
2346
2347         /*
2348          * This is called under the context of state->src_fsp.
2349          */
2350
2351         state->next_io_size = MIN(state->remaining, talloc_array_length(state->buf));
2352
2353         init_strict_lock_struct(state->src_fsp,
2354                                 state->src_fsp->op->global->open_persistent_id,
2355                                 state->src_off,
2356                                 state->next_io_size,
2357                                 READ_LOCK,
2358                                 &read_lck);
2359
2360         ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
2361                                  state->src_fsp,
2362                                  &read_lck);
2363         if (!ok) {
2364                 return NT_STATUS_FILE_LOCK_CONFLICT;
2365         }
2366
2367         subreq = SMB_VFS_PREAD_SEND(state,
2368                                     state->src_ev,
2369                                     state->src_fsp,
2370                                     state->buf,
2371                                     state->next_io_size,
2372                                     state->src_off);
2373         if (subreq == NULL) {
2374                 return NT_STATUS_NO_MEMORY;
2375         }
2376         tevent_req_set_callback(subreq, vfswrap_offload_write_read_done, req);
2377
2378         return NT_STATUS_OK;
2379 }
2380
2381 static void vfswrap_offload_write_write_done(struct tevent_req *subreq);
2382
2383 static void vfswrap_offload_write_read_done(struct tevent_req *subreq)
2384 {
2385         struct tevent_req *req = tevent_req_callback_data(
2386                 subreq, struct tevent_req);
2387         struct vfswrap_offload_write_state *state = tevent_req_data(
2388                 req, struct vfswrap_offload_write_state);
2389         struct vfs_aio_state aio_state;
2390         struct lock_struct write_lck;
2391         ssize_t nread;
2392         bool ok;
2393
2394         nread = SMB_VFS_PREAD_RECV(subreq, &aio_state);
2395         TALLOC_FREE(subreq);
2396         if (nread == -1) {
2397                 DBG_ERR("read failed: %s\n", strerror(aio_state.error));
2398                 tevent_req_nterror(req, map_nt_error_from_unix(aio_state.error));
2399                 return;
2400         }
2401         if (nread != state->next_io_size) {
2402                 DBG_ERR("Short read, only %zd of %zu\n",
2403                         nread, state->next_io_size);
2404                 tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
2405                 return;
2406         }
2407
2408         state->src_off += nread;
2409
2410         ok = change_to_user_and_service_by_fsp(state->dst_fsp);
2411         if (!ok) {
2412                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
2413                 return;
2414         }
2415
2416         init_strict_lock_struct(state->dst_fsp,
2417                                 state->dst_fsp->op->global->open_persistent_id,
2418                                 state->dst_off,
2419                                 state->next_io_size,
2420                                 WRITE_LOCK,
2421                                 &write_lck);
2422
2423         ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
2424                                  state->dst_fsp,
2425                                  &write_lck);
2426         if (!ok) {
2427                 tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
2428                 return;
2429         }
2430
2431         subreq = SMB_VFS_PWRITE_SEND(state,
2432                                      state->dst_ev,
2433                                      state->dst_fsp,
2434                                      state->buf,
2435                                      state->next_io_size,
2436                                      state->dst_off);
2437         if (subreq == NULL) {
2438                 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
2439                 return;
2440         }
2441         tevent_req_set_callback(subreq, vfswrap_offload_write_write_done, req);
2442 }
2443
2444 static void vfswrap_offload_write_write_done(struct tevent_req *subreq)
2445 {
2446         struct tevent_req *req = tevent_req_callback_data(
2447                 subreq, struct tevent_req);
2448         struct vfswrap_offload_write_state *state = tevent_req_data(
2449                 req, struct vfswrap_offload_write_state);
2450         struct vfs_aio_state aio_state;
2451         ssize_t nwritten;
2452         NTSTATUS status;
2453         bool ok;
2454
2455         nwritten = SMB_VFS_PWRITE_RECV(subreq, &aio_state);
2456         TALLOC_FREE(subreq);
2457         if (nwritten == -1) {
2458                 DBG_ERR("write failed: %s\n", strerror(aio_state.error));
2459                 tevent_req_nterror(req, map_nt_error_from_unix(aio_state.error));
2460                 return;
2461         }
2462         if (nwritten != state->next_io_size) {
2463                 DBG_ERR("Short write, only %zd of %zu\n", nwritten, state->next_io_size);
2464                 tevent_req_nterror(req, NT_STATUS_IO_DEVICE_ERROR);
2465                 return;
2466         }
2467
2468         state->dst_off += nwritten;
2469
2470         if (state->remaining < nwritten) {
2471                 /* Paranoia check */
2472                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
2473                 return;
2474         }
2475         state->copied += nwritten;
2476         state->remaining -= nwritten;
2477         if (state->remaining == 0) {
2478                 tevent_req_done(req);
2479                 return;
2480         }
2481
2482         ok = change_to_user_and_service_by_fsp(state->src_fsp);
2483         if (!ok) {
2484                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
2485                 return;
2486         }
2487
2488         status = vfswrap_offload_write_loop(req);
2489         if (!NT_STATUS_IS_OK(status)) {
2490                 tevent_req_nterror(req, status);
2491                 return;
2492         }
2493
2494         return;
2495 }
2496
2497 static NTSTATUS vfswrap_offload_write_recv(struct vfs_handle_struct *handle,
2498                                         struct tevent_req *req,
2499                                         off_t *copied)
2500 {
2501         struct vfswrap_offload_write_state *state = tevent_req_data(
2502                 req, struct vfswrap_offload_write_state);
2503         NTSTATUS status;
2504
2505         if (tevent_req_is_nterror(req, &status)) {
2506                 DBG_DEBUG("copy chunk failed: %s\n", nt_errstr(status));
2507                 *copied = 0;
2508                 tevent_req_received(req);
2509                 return status;
2510         }
2511
2512         *copied = state->copied;
2513         DBG_DEBUG("copy chunk copied %lu\n", (unsigned long)*copied);
2514         tevent_req_received(req);
2515
2516         return NT_STATUS_OK;
2517 }
2518
2519 static NTSTATUS vfswrap_fget_compression(struct vfs_handle_struct *handle,
2520                                         TALLOC_CTX *mem_ctx,
2521                                         struct files_struct *fsp,
2522                                         uint16_t *_compression_fmt)
2523 {
2524         return NT_STATUS_INVALID_DEVICE_REQUEST;
2525 }
2526
2527 static NTSTATUS vfswrap_set_compression(struct vfs_handle_struct *handle,
2528                                         TALLOC_CTX *mem_ctx,
2529                                         struct files_struct *fsp,
2530                                         uint16_t compression_fmt)
2531 {
2532         return NT_STATUS_INVALID_DEVICE_REQUEST;
2533 }
2534
2535 /********************************************************************
2536  Given a stat buffer return the allocated size on disk, taking into
2537  account sparse files.
2538 ********************************************************************/
2539 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
2540                                        struct files_struct *fsp,
2541                                        const SMB_STRUCT_STAT *sbuf)
2542 {
2543         uint64_t result;
2544
2545         START_PROFILE(syscall_get_alloc_size);
2546
2547         if(S_ISDIR(sbuf->st_ex_mode)) {
2548                 result = 0;
2549                 goto out;
2550         }
2551
2552 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
2553         /* The type of st_blocksize is blkcnt_t which *MUST* be
2554            signed (according to POSIX) and can be less than 64-bits.
2555            Ensure when we're converting to 64 bits wide we don't
2556            sign extend. */
2557 #if defined(SIZEOF_BLKCNT_T_8)
2558         result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
2559 #elif defined(SIZEOF_BLKCNT_T_4)
2560         {
2561                 uint64_t bs = ((uint64_t)sbuf->st_ex_blocks) & 0xFFFFFFFFLL;
2562                 result = (uint64_t)STAT_ST_BLOCKSIZE * bs;
2563         }
2564 #else
2565 #error SIZEOF_BLKCNT_T_NOT_A_SUPPORTED_VALUE
2566 #endif
2567         if (result == 0) {
2568                 /*
2569                  * Some file systems do not allocate a block for very
2570                  * small files. But for non-empty file should report a
2571                  * positive size.
2572                  */
2573
2574                 uint64_t filesize = get_file_size_stat(sbuf);
2575                 if (filesize > 0) {
2576                         result = MIN((uint64_t)STAT_ST_BLOCKSIZE, filesize);
2577                 }
2578         }
2579 #else
2580         result = get_file_size_stat(sbuf);
2581 #endif
2582
2583         if (fsp && fsp->initial_allocation_size)
2584                 result = MAX(result,fsp->initial_allocation_size);
2585
2586         result = smb_roundup(handle->conn, result);
2587
2588  out:
2589         END_PROFILE(syscall_get_alloc_size);
2590         return result;
2591 }
2592
2593 static int vfswrap_unlinkat(vfs_handle_struct *handle,
2594                         struct files_struct *dirfsp,
2595                         const struct smb_filename *smb_fname,
2596                         int flags)
2597 {
2598         int result = -1;
2599
2600         START_PROFILE(syscall_unlinkat);
2601
2602         if (is_named_stream(smb_fname)) {
2603                 errno = ENOENT;
2604                 goto out;
2605         }
2606         result = unlinkat(fsp_get_pathref_fd(dirfsp),
2607                         smb_fname->base_name,
2608                         flags);
2609
2610  out:
2611         END_PROFILE(syscall_unlinkat);
2612         return result;
2613 }
2614
2615 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
2616 {
2617         int result;
2618
2619         START_PROFILE(syscall_fchmod);
2620
2621         if (!fsp->fsp_flags.is_pathref) {
2622                 result = fchmod(fsp_get_io_fd(fsp), mode);
2623                 END_PROFILE(syscall_fchmod);
2624                 return result;
2625         }
2626
2627         if (fsp->fsp_flags.have_proc_fds) {
2628                 int fd = fsp_get_pathref_fd(fsp);
2629                 const char *p = NULL;
2630                 char buf[PATH_MAX];
2631
2632                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
2633                 if (p != NULL) {
2634                         result = chmod(p, mode);
2635                 } else {
2636                         result = -1;
2637                 }
2638                 END_PROFILE(syscall_fchmod);
2639                 return result;
2640         }
2641
2642         /*
2643          * This is no longer a handle based call.
2644          */
2645         result = chmod(fsp->fsp_name->base_name, mode);
2646
2647         END_PROFILE(syscall_fchmod);
2648         return result;
2649 }
2650
2651 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
2652 {
2653 #ifdef HAVE_FCHOWN
2654         int result;
2655
2656         START_PROFILE(syscall_fchown);
2657         if (!fsp->fsp_flags.is_pathref) {
2658                 result = fchown(fsp_get_io_fd(fsp), uid, gid);
2659                 END_PROFILE(syscall_fchown);
2660                 return result;
2661         }
2662
2663         if (fsp->fsp_flags.have_proc_fds) {
2664                 int fd = fsp_get_pathref_fd(fsp);
2665                 const char *p = NULL;
2666                 char buf[PATH_MAX];
2667
2668                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
2669                 if (p != NULL) {
2670                         result = chown(p, uid, gid);
2671                 } else {
2672                         result = -1;
2673                 }
2674                 END_PROFILE(syscall_fchown);
2675                 return result;
2676         }
2677
2678         /*
2679          * This is no longer a handle based call.
2680          */
2681         result = chown(fsp->fsp_name->base_name, uid, gid);
2682         END_PROFILE(syscall_fchown);
2683         return result;
2684 #else
2685         errno = ENOSYS;
2686         return -1;
2687 #endif
2688 }
2689
2690 static int vfswrap_lchown(vfs_handle_struct *handle,
2691                         const struct smb_filename *smb_fname,
2692                         uid_t uid,
2693                         gid_t gid)
2694 {
2695         int result;
2696
2697         START_PROFILE(syscall_lchown);
2698         result = lchown(smb_fname->base_name, uid, gid);
2699         END_PROFILE(syscall_lchown);
2700         return result;
2701 }
2702
2703 static int vfswrap_chdir(vfs_handle_struct *handle,
2704                         const struct smb_filename *smb_fname)
2705 {
2706         int result;
2707
2708         START_PROFILE(syscall_chdir);
2709         result = chdir(smb_fname->base_name);
2710         END_PROFILE(syscall_chdir);
2711         return result;
2712 }
2713
2714 static struct smb_filename *vfswrap_getwd(vfs_handle_struct *handle,
2715                                 TALLOC_CTX *ctx)
2716 {
2717         char *result;
2718         struct smb_filename *smb_fname = NULL;
2719
2720         START_PROFILE(syscall_getwd);
2721         result = sys_getwd();
2722         END_PROFILE(syscall_getwd);
2723
2724         if (result == NULL) {
2725                 return NULL;
2726         }
2727         smb_fname = synthetic_smb_fname(ctx,
2728                                 result,
2729                                 NULL,
2730                                 NULL,
2731                                 0,
2732                                 0);
2733         /*
2734          * sys_getwd() *always* returns malloced memory.
2735          * We must free here to avoid leaks:
2736          * BUG:https://bugzilla.samba.org/show_bug.cgi?id=13372
2737          */
2738         SAFE_FREE(result);
2739         return smb_fname;
2740 }
2741
2742 /*********************************************************************
2743  nsec timestamp resolution call. Convert down to whatever the underlying
2744  system will support.
2745 **********************************************************************/
2746
2747 static int vfswrap_fntimes(vfs_handle_struct *handle,
2748                            files_struct *fsp,
2749                            struct smb_file_time *ft)
2750 {
2751         int result = -1;
2752         struct timespec ts[2];
2753         struct timespec *times = NULL;
2754
2755         START_PROFILE(syscall_fntimes);
2756
2757         if (is_named_stream(fsp->fsp_name)) {
2758                 errno = ENOENT;
2759                 goto out;
2760         }
2761
2762         if (ft != NULL) {
2763                 if (is_omit_timespec(&ft->atime)) {
2764                         ft->atime = fsp->fsp_name->st.st_ex_atime;
2765                 }
2766
2767                 if (is_omit_timespec(&ft->mtime)) {
2768                         ft->mtime = fsp->fsp_name->st.st_ex_mtime;
2769                 }
2770
2771                 if (!is_omit_timespec(&ft->create_time)) {
2772                         set_create_timespec_ea(fsp,
2773                                                ft->create_time);
2774                 }
2775
2776                 if ((timespec_compare(&ft->atime,
2777                                       &fsp->fsp_name->st.st_ex_atime) == 0) &&
2778                     (timespec_compare(&ft->mtime,
2779                                       &fsp->fsp_name->st.st_ex_mtime) == 0)) {
2780                         result = 0;
2781                         goto out;
2782                 }
2783
2784                 ts[0] = ft->atime;
2785                 ts[1] = ft->mtime;
2786                 times = ts;
2787         } else {
2788                 times = NULL;
2789         }
2790
2791         if (!fsp->fsp_flags.is_pathref) {
2792                 result = futimens(fsp_get_io_fd(fsp), times);
2793                 goto out;
2794         }
2795
2796         if (fsp->fsp_flags.have_proc_fds) {
2797                 int fd = fsp_get_pathref_fd(fsp);
2798                 const char *p = NULL;
2799                 char buf[PATH_MAX];
2800
2801                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
2802                 if (p != NULL) {
2803                         /*
2804                          * The dirfd argument of utimensat is ignored when
2805                          * pathname is an absolute path
2806                          */
2807                         result = utimensat(AT_FDCWD, p, times, 0);
2808                 } else {
2809                         result = -1;
2810                 }
2811
2812                 goto out;
2813         }
2814
2815         /*
2816          * The fd is a pathref (opened with O_PATH) and there isn't fd to
2817          * path translation mechanism. Fallback to path based call.
2818          */
2819         result = utimensat(AT_FDCWD, fsp->fsp_name->base_name, times, 0);
2820
2821 out:
2822         END_PROFILE(syscall_fntimes);
2823
2824         return result;
2825 }
2826
2827
2828 /*********************************************************************
2829  A version of ftruncate that will write the space on disk if strict
2830  allocate is set.
2831 **********************************************************************/
2832
2833 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
2834 {
2835         off_t space_to_write;
2836         uint64_t space_avail;
2837         uint64_t bsize,dfree,dsize;
2838         int ret;
2839         NTSTATUS status;
2840         SMB_STRUCT_STAT *pst;
2841         bool ok;
2842
2843         ok = vfs_valid_pwrite_range(len, 0);
2844         if (!ok) {
2845                 errno = EINVAL;
2846                 return -1;
2847         }
2848
2849         status = vfs_stat_fsp(fsp);
2850         if (!NT_STATUS_IS_OK(status)) {
2851                 return -1;
2852         }
2853         pst = &fsp->fsp_name->st;
2854
2855 #ifdef S_ISFIFO
2856         if (S_ISFIFO(pst->st_ex_mode))
2857                 return 0;
2858 #endif
2859
2860         if (pst->st_ex_size == len)
2861                 return 0;
2862
2863         /* Shrink - just ftruncate. */
2864         if (pst->st_ex_size > len)
2865                 return ftruncate(fsp_get_io_fd(fsp), len);
2866
2867         space_to_write = len - pst->st_ex_size;
2868
2869         /* for allocation try fallocate first. This can fail on some
2870            platforms e.g. when the filesystem doesn't support it and no
2871            emulation is being done by the libc (like on AIX with JFS1). In that
2872            case we do our own emulation. fallocate implementations can
2873            return ENOTSUP or EINVAL in cases like that. */
2874         ret = SMB_VFS_FALLOCATE(fsp, 0, pst->st_ex_size, space_to_write);
2875         if (ret == -1 && errno == ENOSPC) {
2876                 return -1;
2877         }
2878         if (ret == 0) {
2879                 return 0;
2880         }
2881         DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
2882                 "error %d. Falling back to slow manual allocation\n", errno));
2883
2884         /* available disk space is enough or not? */
2885         space_avail =
2886             get_dfree_info(fsp->conn, fsp->fsp_name, &bsize, &dfree, &dsize);
2887         /* space_avail is 1k blocks */
2888         if (space_avail == (uint64_t)-1 ||
2889                         ((uint64_t)space_to_write/1024 > space_avail) ) {
2890                 errno = ENOSPC;
2891                 return -1;
2892         }
2893
2894         /* Write out the real space on disk. */
2895         ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
2896         if (ret != 0) {
2897                 return -1;
2898         }
2899
2900         return 0;
2901 }
2902
2903 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
2904 {
2905         int result = -1;
2906         SMB_STRUCT_STAT *pst;
2907         NTSTATUS status;
2908         char c = 0;
2909
2910         START_PROFILE(syscall_ftruncate);
2911
2912         if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->fsp_flags.is_sparse) {
2913                 result = strict_allocate_ftruncate(handle, fsp, len);
2914                 END_PROFILE(syscall_ftruncate);
2915                 return result;
2916         }
2917
2918         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
2919            ftruncate if the system supports it. Then I discovered that
2920            you can have some filesystems that support ftruncate
2921            expansion and some that don't! On Linux fat can't do
2922            ftruncate extend but ext2 can. */
2923
2924         result = ftruncate(fsp_get_io_fd(fsp), len);
2925
2926         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
2927            extend a file with ftruncate. Provide alternate implementation
2928            for this */
2929
2930         /* Do an fstat to see if the file is longer than the requested
2931            size in which case the ftruncate above should have
2932            succeeded or shorter, in which case seek to len - 1 and
2933            write 1 byte of zero */
2934         status = vfs_stat_fsp(fsp);
2935         if (!NT_STATUS_IS_OK(status)) {
2936                 goto done;
2937         }
2938
2939         /* We need to update the files_struct after successful ftruncate */
2940         if (result == 0) {
2941                 goto done;
2942         }
2943
2944         pst = &fsp->fsp_name->st;
2945
2946 #ifdef S_ISFIFO
2947         if (S_ISFIFO(pst->st_ex_mode)) {
2948                 result = 0;
2949                 goto done;
2950         }
2951 #endif
2952
2953         if (pst->st_ex_size == len) {
2954                 result = 0;
2955                 goto done;
2956         }
2957
2958         if (pst->st_ex_size > len) {
2959                 /* the ftruncate should have worked */
2960                 goto done;
2961         }
2962
2963         if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
2964                 goto done;
2965         }
2966
2967         result = 0;
2968
2969   done:
2970
2971         END_PROFILE(syscall_ftruncate);
2972         return result;
2973 }
2974
2975 static int vfswrap_fallocate(vfs_handle_struct *handle,
2976                         files_struct *fsp,
2977                         uint32_t mode,
2978                         off_t offset,
2979                         off_t len)
2980 {
2981         int result;
2982
2983         START_PROFILE(syscall_fallocate);
2984         if (mode == 0) {
2985                 result = sys_posix_fallocate(fsp_get_io_fd(fsp), offset, len);
2986                 /*
2987                  * posix_fallocate returns 0 on success, errno on error
2988                  * and doesn't set errno. Make it behave like fallocate()
2989                  * which returns -1, and sets errno on failure.
2990                  */
2991                 if (result != 0) {
2992                         errno = result;
2993                         result = -1;
2994                 }
2995         } else {
2996                 /* sys_fallocate handles filtering of unsupported mode flags */
2997                 result = sys_fallocate(fsp_get_io_fd(fsp), mode, offset, len);
2998         }
2999         END_PROFILE(syscall_fallocate);
3000         return result;
3001 }
3002
3003 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
3004 {
3005         bool result;
3006
3007         START_PROFILE(syscall_fcntl_lock);
3008
3009         if (fsp->fsp_flags.use_ofd_locks) {
3010                 op = map_process_lock_to_ofd_lock(op);
3011         }
3012
3013         result =  fcntl_lock(fsp_get_io_fd(fsp), op, offset, count, type);
3014         END_PROFILE(syscall_fcntl_lock);
3015         return result;
3016 }
3017
3018 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
3019                                 uint32_t share_access, uint32_t access_mask)
3020 {
3021         errno = ENOTSUP;
3022         return -1;
3023 }
3024
3025 static int vfswrap_fcntl(vfs_handle_struct *handle, files_struct *fsp, int cmd,
3026                          va_list cmd_arg)
3027 {
3028         void *argp;
3029         va_list dup_cmd_arg;
3030         int result;
3031         int val;
3032
3033         START_PROFILE(syscall_fcntl);
3034
3035         va_copy(dup_cmd_arg, cmd_arg);
3036
3037         switch(cmd) {
3038         case F_SETLK:
3039         case F_SETLKW:
3040         case F_GETLK:
3041 #if defined(HAVE_OFD_LOCKS)
3042         case F_OFD_SETLK:
3043         case F_OFD_SETLKW:
3044         case F_OFD_GETLK:
3045 #endif
3046 #if defined(HAVE_F_OWNER_EX)
3047         case F_GETOWN_EX:
3048         case F_SETOWN_EX:
3049 #endif
3050 #if defined(HAVE_RW_HINTS)
3051         case F_GET_RW_HINT:
3052         case F_SET_RW_HINT:
3053         case F_GET_FILE_RW_HINT:
3054         case F_SET_FILE_RW_HINT:
3055 #endif
3056                 argp = va_arg(dup_cmd_arg, void *);
3057                 result = sys_fcntl_ptr(fsp_get_io_fd(fsp), cmd, argp);
3058                 break;
3059         default:
3060                 val = va_arg(dup_cmd_arg, int);
3061                 result = sys_fcntl_int(fsp_get_io_fd(fsp), cmd, val);
3062         }
3063
3064         va_end(dup_cmd_arg);
3065
3066         END_PROFILE(syscall_fcntl);
3067         return result;
3068 }
3069
3070 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
3071 {
3072         bool result;
3073         int op = F_GETLK;
3074
3075         START_PROFILE(syscall_fcntl_getlock);
3076
3077         if (fsp->fsp_flags.use_ofd_locks) {
3078                 op = map_process_lock_to_ofd_lock(op);
3079         }
3080
3081         result = fcntl_getlock(fsp_get_io_fd(fsp), op, poffset, pcount, ptype, ppid);
3082         END_PROFILE(syscall_fcntl_getlock);
3083         return result;
3084 }
3085
3086 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
3087                                 int leasetype)
3088 {
3089         int result = -1;
3090
3091         START_PROFILE(syscall_linux_setlease);
3092
3093 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
3094         result = linux_setlease(fsp_get_io_fd(fsp), leasetype);
3095 #else
3096         errno = ENOSYS;
3097 #endif
3098         END_PROFILE(syscall_linux_setlease);
3099         return result;
3100 }
3101
3102 static int vfswrap_symlinkat(vfs_handle_struct *handle,
3103                         const struct smb_filename *link_target,
3104                         struct files_struct *dirfsp,
3105                         const struct smb_filename *new_smb_fname)
3106 {
3107         int result;
3108
3109         START_PROFILE(syscall_symlinkat);
3110
3111         result = symlinkat(link_target->base_name,
3112                         fsp_get_pathref_fd(dirfsp),
3113                         new_smb_fname->base_name);
3114         END_PROFILE(syscall_symlinkat);
3115         return result;
3116 }
3117
3118 static int vfswrap_readlinkat(vfs_handle_struct *handle,
3119                         const struct files_struct *dirfsp,
3120                         const struct smb_filename *smb_fname,
3121                         char *buf,
3122                         size_t bufsiz)
3123 {
3124         int result;
3125
3126         START_PROFILE(syscall_readlinkat);
3127
3128         result = readlinkat(fsp_get_pathref_fd(dirfsp),
3129                         smb_fname->base_name,
3130                         buf,
3131                         bufsiz);
3132
3133         END_PROFILE(syscall_readlinkat);
3134         return result;
3135 }
3136
3137 static int vfswrap_linkat(vfs_handle_struct *handle,
3138                         files_struct *srcfsp,
3139                         const struct smb_filename *old_smb_fname,
3140                         files_struct *dstfsp,
3141                         const struct smb_filename *new_smb_fname,
3142                         int flags)
3143 {
3144         int result;
3145
3146         START_PROFILE(syscall_linkat);
3147
3148         result = linkat(fsp_get_pathref_fd(srcfsp),
3149                         old_smb_fname->base_name,
3150                         fsp_get_pathref_fd(dstfsp),
3151                         new_smb_fname->base_name,
3152                         flags);
3153
3154         END_PROFILE(syscall_linkat);
3155         return result;
3156 }
3157
3158 static int vfswrap_mknodat(vfs_handle_struct *handle,
3159                         files_struct *dirfsp,
3160                         const struct smb_filename *smb_fname,
3161                         mode_t mode,
3162                         SMB_DEV_T dev)
3163 {
3164         int result;
3165
3166         START_PROFILE(syscall_mknodat);
3167
3168         result = sys_mknodat(fsp_get_pathref_fd(dirfsp),
3169                         smb_fname->base_name,
3170                         mode,
3171                         dev);
3172
3173         END_PROFILE(syscall_mknodat);
3174         return result;
3175 }
3176
3177 static struct smb_filename *vfswrap_realpath(vfs_handle_struct *handle,
3178                         TALLOC_CTX *ctx,
3179                         const struct smb_filename *smb_fname)
3180 {
3181         char *result;
3182         struct smb_filename *result_fname = NULL;
3183
3184         START_PROFILE(syscall_realpath);
3185         result = sys_realpath(smb_fname->base_name);
3186         END_PROFILE(syscall_realpath);
3187         if (result) {
3188                 result_fname = synthetic_smb_fname(ctx,
3189                                                    result,
3190                                                    NULL,
3191                                                    NULL,
3192                                                    0,
3193                                                    0);
3194                 SAFE_FREE(result);
3195         }
3196         return result_fname;
3197 }
3198
3199 static int vfswrap_fchflags(vfs_handle_struct *handle,
3200                         struct files_struct *fsp,
3201                         unsigned int flags)
3202 {
3203 #ifdef HAVE_FCHFLAGS
3204         int fd = fsp_get_pathref_fd(fsp);
3205
3206         if (!fsp->fsp_flags.is_pathref) {
3207                 return fchflags(fd, flags);
3208         }
3209
3210         if (fsp->fsp_flags.have_proc_fds) {
3211                 const char *p = NULL;
3212                 char buf[PATH_MAX];
3213
3214                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
3215                 if (p == NULL) {
3216                         return -1;
3217                 }
3218
3219                 return chflags(p, flags);
3220         }
3221
3222         /*
3223          * This is no longer a handle based call.
3224          */
3225         return chflags(fsp->fsp_name->base_name, flags);
3226 #else
3227         errno = ENOSYS;
3228         return -1;
3229 #endif
3230 }
3231
3232 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
3233                                              const SMB_STRUCT_STAT *sbuf)
3234 {
3235         struct file_id key;
3236
3237         /* the ZERO_STRUCT ensures padding doesn't break using the key as a
3238          * blob */
3239         ZERO_STRUCT(key);
3240
3241         key.devid = sbuf->st_ex_dev;
3242         key.inode = sbuf->st_ex_ino;
3243         /* key.extid is unused by default. */
3244
3245         return key;
3246 }
3247
3248 static uint64_t vfswrap_fs_file_id(struct vfs_handle_struct *handle,
3249                                    const SMB_STRUCT_STAT *psbuf)
3250 {
3251         uint64_t file_id;
3252
3253         if (!(psbuf->st_ex_iflags & ST_EX_IFLAG_CALCULATED_FILE_ID)) {
3254                 return psbuf->st_ex_file_id;
3255         }
3256
3257         if (handle->conn->base_share_dev == psbuf->st_ex_dev) {
3258                 return (uint64_t)psbuf->st_ex_ino;
3259         }
3260
3261         /* FileIDLow */
3262         file_id = ((psbuf->st_ex_ino) & UINT32_MAX);
3263
3264         /* FileIDHigh */
3265         file_id |= ((uint64_t)((psbuf->st_ex_dev) & UINT32_MAX)) << 32;
3266
3267         return file_id;
3268 }
3269
3270 static NTSTATUS vfswrap_fstreaminfo(vfs_handle_struct *handle,
3271                                    struct files_struct *fsp,
3272                                    TALLOC_CTX *mem_ctx,
3273                                    unsigned int *pnum_streams,
3274                                    struct stream_struct **pstreams)
3275 {
3276         struct stream_struct *tmp_streams = NULL;
3277         unsigned int num_streams = *pnum_streams;
3278         struct stream_struct *streams = *pstreams;
3279         NTSTATUS status;
3280
3281         if (fsp->fsp_flags.is_directory) {
3282                 /*
3283                  * No default streams on directories
3284                  */
3285                 goto done;
3286         }
3287         status = vfs_stat_fsp(fsp);
3288         if (!NT_STATUS_IS_OK(status)) {
3289                 return status;
3290         }
3291
3292         if (num_streams + 1 < 1) {
3293                 /* Integer wrap. */
3294                 return NT_STATUS_INVALID_PARAMETER;
3295         }
3296
3297         tmp_streams = talloc_realloc(mem_ctx,
3298                                         streams,
3299                                         struct stream_struct,
3300                                         num_streams + 1);
3301         if (tmp_streams == NULL) {
3302                 return NT_STATUS_NO_MEMORY;
3303         }
3304         tmp_streams[num_streams].name = talloc_strdup(tmp_streams, "::$DATA");
3305         if (tmp_streams[num_streams].name == NULL) {
3306                 return NT_STATUS_NO_MEMORY;
3307         }
3308         tmp_streams[num_streams].size = fsp->fsp_name->st.st_ex_size;
3309         tmp_streams[num_streams].alloc_size = SMB_VFS_GET_ALLOC_SIZE(
3310                                                 handle->conn,
3311                                                 fsp,
3312                                                 &fsp->fsp_name->st);
3313         num_streams += 1;
3314
3315         *pnum_streams = num_streams;
3316         *pstreams = tmp_streams;
3317  done:
3318         return NT_STATUS_OK;
3319 }
3320
3321 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
3322                                      const struct smb_filename *path,
3323                                      const char *name,
3324                                      TALLOC_CTX *mem_ctx,
3325                                      char **found_name)
3326 {
3327         /*
3328          * Don't fall back to get_real_filename so callers can differentiate
3329          * between a full directory scan and an actual case-insensitive stat.
3330          */
3331         errno = EOPNOTSUPP;
3332         return -1;
3333 }
3334
3335 static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
3336                                    const struct smb_filename *smb_fname)
3337 {
3338         return handle->conn->connectpath;
3339 }
3340
3341 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
3342                                          struct byte_range_lock *br_lck,
3343                                          struct lock_struct *plock)
3344 {
3345         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
3346
3347         /* Note: blr is not used in the default implementation. */
3348         return brl_lock_windows_default(br_lck, plock);
3349 }
3350
3351 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
3352                                        struct byte_range_lock *br_lck,
3353                                        const struct lock_struct *plock)
3354 {
3355         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
3356
3357         return brl_unlock_windows_default(br_lck, plock);
3358 }
3359
3360 static bool vfswrap_strict_lock_check(struct vfs_handle_struct *handle,
3361                                       files_struct *fsp,
3362                                       struct lock_struct *plock)
3363 {
3364         SMB_ASSERT(plock->lock_type == READ_LOCK ||
3365             plock->lock_type == WRITE_LOCK);
3366
3367         return strict_lock_check_default(fsp, plock);
3368 }
3369
3370 /* NT ACL operations. */
3371
3372 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
3373                                     files_struct *fsp,
3374                                     uint32_t security_info,
3375                                     TALLOC_CTX *mem_ctx,
3376                                     struct security_descriptor **ppdesc)
3377 {
3378         NTSTATUS result;
3379
3380         START_PROFILE(fget_nt_acl);
3381         result = posix_fget_nt_acl(fsp, security_info,
3382                                    mem_ctx, ppdesc);
3383         END_PROFILE(fget_nt_acl);
3384         return result;
3385 }
3386
3387 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32_t security_info_sent, const struct security_descriptor *psd)
3388 {
3389         NTSTATUS result;
3390
3391         START_PROFILE(fset_nt_acl);
3392         result = set_nt_acl(fsp, security_info_sent, psd);
3393         END_PROFILE(fset_nt_acl);
3394         return result;
3395 }
3396
3397 static NTSTATUS vfswrap_audit_file(struct vfs_handle_struct *handle,
3398                                    struct smb_filename *file,
3399                                    struct security_acl *sacl,
3400                                    uint32_t access_requested,
3401                                    uint32_t access_denied)
3402 {
3403         return NT_STATUS_OK; /* Nothing to do here ... */
3404 }
3405
3406 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle,
3407                                         files_struct *fsp,
3408                                         SMB_ACL_TYPE_T type,
3409                                         TALLOC_CTX *mem_ctx)
3410 {
3411         return sys_acl_get_fd(handle, fsp, type, mem_ctx);
3412 }
3413
3414 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle,
3415                                   files_struct *fsp,
3416                                   SMB_ACL_TYPE_T type,
3417                                   SMB_ACL_T theacl)
3418 {
3419         return sys_acl_set_fd(handle, fsp, type, theacl);
3420 }
3421
3422 static int vfswrap_sys_acl_delete_def_fd(vfs_handle_struct *handle,
3423                                          files_struct *fsp)
3424 {
3425         return sys_acl_delete_def_fd(handle, fsp);
3426 }
3427
3428 /****************************************************************
3429  Extended attribute operations.
3430 *****************************************************************/
3431
3432 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle,
3433                                  struct files_struct *fsp,
3434                                  const char *name,
3435                                  void *value,
3436                                  size_t size)
3437 {
3438         int fd = fsp_get_pathref_fd(fsp);
3439
3440         if (!fsp->fsp_flags.is_pathref) {
3441                 return fgetxattr(fd, name, value, size);
3442         }
3443
3444         if (fsp->fsp_flags.have_proc_fds) {
3445                 const char *p = NULL;
3446                 char buf[PATH_MAX];
3447
3448                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
3449                 if (p == NULL) {
3450                         return -1;
3451                 }
3452
3453                 return getxattr(p, name, value, size);
3454         }
3455
3456         /*
3457          * This is no longer a handle based call.
3458          */
3459         return getxattr(fsp->fsp_name->base_name, name, value, size);
3460 }
3461
3462 struct vfswrap_getxattrat_state {
3463         struct tevent_context *ev;
3464         struct vfs_handle_struct *handle;
3465         files_struct *dir_fsp;
3466         const struct smb_filename *smb_fname;
3467
3468         /*
3469          * The following variables are talloced off "state" which is protected
3470          * by a destructor and thus are guaranteed to be safe to be used in the
3471          * job function in the worker thread.
3472          */
3473         char *name;
3474         const char *xattr_name;
3475         uint8_t *xattr_value;
3476         struct security_unix_token *token;
3477
3478         ssize_t xattr_size;
3479         struct vfs_aio_state vfs_aio_state;
3480         SMBPROFILE_BYTES_ASYNC_STATE(profile_bytes);
3481 };
3482
3483 static int vfswrap_getxattrat_state_destructor(
3484                 struct vfswrap_getxattrat_state *state)
3485 {
3486         return -1;
3487 }
3488
3489 static void vfswrap_getxattrat_do_sync(struct tevent_req *req);
3490 static void vfswrap_getxattrat_do_async(void *private_data);
3491 static void vfswrap_getxattrat_done(struct tevent_req *subreq);
3492
3493 static struct tevent_req *vfswrap_getxattrat_send(
3494                         TALLOC_CTX *mem_ctx,
3495                         struct tevent_context *ev,
3496                         struct vfs_handle_struct *handle,
3497                         files_struct *dir_fsp,
3498                         const struct smb_filename *smb_fname,
3499                         const char *xattr_name,
3500                         size_t alloc_hint)
3501 {
3502         struct tevent_req *req = NULL;
3503         struct tevent_req *subreq = NULL;
3504         struct vfswrap_getxattrat_state *state = NULL;
3505         size_t max_threads = 0;
3506         bool have_per_thread_cwd = false;
3507         bool have_per_thread_creds = false;
3508         bool do_async = false;
3509
3510         req = tevent_req_create(mem_ctx, &state,
3511                                 struct vfswrap_getxattrat_state);
3512         if (req == NULL) {
3513                 return NULL;
3514         }
3515         *state = (struct vfswrap_getxattrat_state) {
3516                 .ev = ev,
3517                 .handle = handle,
3518                 .dir_fsp = dir_fsp,
3519                 .smb_fname = smb_fname,
3520         };
3521
3522         max_threads = pthreadpool_tevent_max_threads(dir_fsp->conn->sconn->pool);
3523         if (max_threads >= 1) {
3524                 /*
3525                  * We need a non sync threadpool!
3526                  */
3527                 have_per_thread_cwd = per_thread_cwd_supported();
3528         }
3529 #ifdef HAVE_LINUX_THREAD_CREDENTIALS
3530         have_per_thread_creds = true;
3531 #endif
3532         if (have_per_thread_cwd && have_per_thread_creds) {
3533                 do_async = true;
3534         }
3535
3536         SMBPROFILE_BYTES_ASYNC_START(syscall_asys_getxattrat, profile_p,
3537                                      state->profile_bytes, 0);
3538
3539         if (fsp_get_pathref_fd(dir_fsp) == -1) {
3540                 DBG_ERR("Need a valid directory fd\n");
3541                 tevent_req_error(req, EINVAL);
3542                 return tevent_req_post(req, ev);
3543         }
3544
3545         if (alloc_hint > 0) {
3546                 state->xattr_value = talloc_zero_array(state,
3547                                                        uint8_t,
3548                                                        alloc_hint);
3549                 if (tevent_req_nomem(state->xattr_value, req)) {
3550                         return tevent_req_post(req, ev);
3551                 }
3552         }
3553
3554         if (!do_async) {
3555                 vfswrap_getxattrat_do_sync(req);
3556                 return tevent_req_post(req, ev);
3557         }
3558
3559         /*
3560          * Now allocate all parameters from a memory context that won't go away
3561          * no matter what. These paremeters will get used in threads and we
3562          * can't reliably cancel threads, so all buffers passed to the threads
3563          * must not be freed before all referencing threads terminate.
3564          */
3565
3566         state->name = talloc_strdup(state, smb_fname->base_name);
3567         if (tevent_req_nomem(state->name, req)) {
3568                 return tevent_req_post(req, ev);
3569         }
3570
3571         state->xattr_name = talloc_strdup(state, xattr_name);
3572         if (tevent_req_nomem(state->xattr_name, req)) {
3573                 return tevent_req_post(req, ev);
3574         }
3575
3576         /*
3577          * This is a hot codepath so at first glance one might think we should
3578          * somehow optimize away the token allocation and do a
3579          * talloc_reference() or similar black magic instead. But due to the
3580          * talloc_stackframe pool per SMB2 request this should be a simple copy
3581          * without a malloc in most cases.
3582          */
3583         if (geteuid() == sec_initial_uid()) {
3584                 state->token = root_unix_token(state);
3585         } else {
3586                 state->token = copy_unix_token(
3587                                         state,
3588                                         dir_fsp->conn->session_info->unix_token);
3589         }
3590         if (tevent_req_nomem(state->token, req)) {
3591                 return tevent_req_post(req, ev);
3592         }
3593
3594         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
3595
3596         subreq = pthreadpool_tevent_job_send(
3597                         state,
3598                         ev,
3599                         dir_fsp->conn->sconn->pool,
3600                         vfswrap_getxattrat_do_async,
3601                         state);
3602         if (tevent_req_nomem(subreq, req)) {
3603                 return tevent_req_post(req, ev);
3604         }
3605         tevent_req_set_callback(subreq, vfswrap_getxattrat_done, req);
3606
3607         talloc_set_destructor(state, vfswrap_getxattrat_state_destructor);
3608
3609         return req;
3610 }
3611
3612 static void vfswrap_getxattrat_do_sync(struct tevent_req *req)
3613 {
3614         struct vfswrap_getxattrat_state *state = tevent_req_data(
3615                 req, struct vfswrap_getxattrat_state);
3616         struct files_struct *fsp = state->smb_fname->fsp;
3617
3618         if (fsp->base_fsp != NULL) {
3619                 fsp = fsp->base_fsp;
3620         }
3621
3622         state->xattr_size = vfswrap_fgetxattr(state->handle,
3623                                               fsp,
3624                                               state->xattr_name,
3625                                               state->xattr_value,
3626                                               talloc_array_length(state->xattr_value));
3627         if (state->xattr_size == -1) {
3628                 tevent_req_error(req, errno);
3629                 return;
3630         }
3631
3632         tevent_req_done(req);
3633         return;
3634 }
3635
3636 static void vfswrap_getxattrat_do_async(void *private_data)
3637 {
3638         struct vfswrap_getxattrat_state *state = talloc_get_type_abort(
3639                 private_data, struct vfswrap_getxattrat_state);
3640         struct timespec start_time;
3641         struct timespec end_time;
3642         int ret;
3643         struct files_struct *fsp = state->smb_fname->fsp;
3644
3645         if (fsp->base_fsp != NULL) {
3646                 fsp = fsp->base_fsp;
3647         }
3648
3649         PROFILE_TIMESTAMP(&start_time);
3650         SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);
3651
3652         /*
3653          * Here we simulate a getxattrat()
3654          * call using fchdir();getxattr()
3655          */
3656
3657         per_thread_cwd_activate();
3658
3659         /* Become the correct credential on this thread. */
3660         ret = set_thread_credentials(state->token->uid,
3661                                      state->token->gid,
3662                                      (size_t)state->token->ngroups,
3663                                      state->token->groups);
3664         if (ret != 0) {
3665                 state->xattr_size = -1;
3666                 state->vfs_aio_state.error = errno;
3667                 goto end_profile;
3668         }
3669
3670         state->xattr_size = vfswrap_fgetxattr(state->handle,
3671                                               fsp,
3672                                               state->xattr_name,
3673                                               state->xattr_value,
3674                                               talloc_array_length(state->xattr_value));
3675         if (state->xattr_size == -1) {
3676                 state->vfs_aio_state.error = errno;
3677         }
3678
3679 end_profile:
3680         PROFILE_TIMESTAMP(&end_time);
3681         state->vfs_aio_state.duration = nsec_time_diff(&end_time, &start_time);
3682         SMBPROFILE_BYTES_ASYNC_SET_IDLE(state->profile_bytes);
3683 }
3684
3685 static void vfswrap_getxattrat_done(struct tevent_req *subreq)
3686 {
3687         struct tevent_req *req = tevent_req_callback_data(
3688                 subreq, struct tevent_req);
3689         struct vfswrap_getxattrat_state *state = tevent_req_data(
3690                 req, struct vfswrap_getxattrat_state);
3691         int ret;
3692         bool ok;
3693
3694         /*
3695          * Make sure we run as the user again
3696          */
3697         ok = change_to_user_and_service_by_fsp(state->dir_fsp);
3698         SMB_ASSERT(ok);
3699
3700         ret = pthreadpool_tevent_job_recv(subreq);
3701         TALLOC_FREE(subreq);
3702         SMBPROFILE_BYTES_ASYNC_END(state->profile_bytes);
3703         talloc_set_destructor(state, NULL);
3704         if (ret != 0) {
3705                 if (ret != EAGAIN) {
3706                         tevent_req_error(req, ret);
3707                         return;
3708                 }
3709                 /*
3710                  * If we get EAGAIN from pthreadpool_tevent_job_recv() this
3711                  * means the lower level pthreadpool failed to create a new
3712                  * thread. Fallback to sync processing in that case to allow
3713                  * some progress for the client.
3714                  */
3715                 vfswrap_getxattrat_do_sync(req);
3716                 return;
3717         }
3718
3719         if (state->xattr_size == -1) {
3720                 tevent_req_error(req, state->vfs_aio_state.error);
3721                 return;
3722         }
3723
3724         if (state->xattr_value == NULL) {
3725                 /*
3726                  * The caller only wanted the size.
3727                  */
3728                 tevent_req_done(req);
3729                 return;
3730         }
3731
3732         /*
3733          * shrink the buffer to the returned size.
3734          * (can't fail). It means NULL if size is 0.
3735          */
3736         state->xattr_value = talloc_realloc(state,
3737                                             state->xattr_value,
3738                                             uint8_t,
3739                                             state->xattr_size);
3740
3741         tevent_req_done(req);
3742 }
3743
3744 static ssize_t vfswrap_getxattrat_recv(struct tevent_req *req,
3745                                        struct vfs_aio_state *aio_state,
3746                                        TALLOC_CTX *mem_ctx,
3747                                        uint8_t **xattr_value)
3748 {
3749         struct vfswrap_getxattrat_state *state = tevent_req_data(
3750                 req, struct vfswrap_getxattrat_state);
3751         ssize_t xattr_size;
3752
3753         if (tevent_req_is_unix_error(req, &aio_state->error)) {
3754                 tevent_req_received(req);
3755                 return -1;
3756         }
3757
3758         *aio_state = state->vfs_aio_state;
3759         xattr_size = state->xattr_size;
3760         if (xattr_value != NULL) {
3761                 *xattr_value = talloc_move(mem_ctx, &state->xattr_value);
3762         }
3763
3764         tevent_req_received(req);
3765         return xattr_size;
3766 }
3767
3768 static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
3769 {
3770         int fd = fsp_get_pathref_fd(fsp);
3771
3772         if (!fsp->fsp_flags.is_pathref) {
3773                 return flistxattr(fd, list, size);
3774         }
3775
3776         if (fsp->fsp_flags.have_proc_fds) {
3777                 const char *p = NULL;
3778                 char buf[PATH_MAX];
3779
3780                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
3781                 if (p == NULL) {
3782                         return -1;
3783                 }
3784
3785                 return listxattr(p, list, size);
3786         }
3787
3788         /*
3789          * This is no longer a handle based call.
3790          */
3791         return listxattr(fsp->fsp_name->base_name, list, size);
3792 }
3793
3794 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
3795 {
3796         int fd = fsp_get_pathref_fd(fsp);
3797
3798         if (!fsp->fsp_flags.is_pathref) {
3799                 return fremovexattr(fd, name);
3800         }
3801
3802         if (fsp->fsp_flags.have_proc_fds) {
3803                 const char *p = NULL;
3804                 char buf[PATH_MAX];
3805
3806                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
3807                 if (p == NULL) {
3808                         return -1;
3809                 }
3810
3811                 return removexattr(p, name);
3812         }
3813
3814         /*
3815          * This is no longer a handle based call.
3816          */
3817         return removexattr(fsp->fsp_name->base_name, name);
3818 }
3819
3820 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
3821 {
3822         int fd = fsp_get_pathref_fd(fsp);
3823
3824         if (!fsp->fsp_flags.is_pathref) {
3825                 return fsetxattr(fd, name, value, size, flags);
3826         }
3827
3828         if (fsp->fsp_flags.have_proc_fds) {
3829                 const char *p = NULL;
3830                 char buf[PATH_MAX];
3831
3832                 p = sys_proc_fd_path(fd, buf, sizeof(buf));
3833                 if (p == NULL) {
3834                         return -1;
3835                 }
3836
3837                 return setxattr(p, name, value, size, flags);
3838         }
3839
3840         /*
3841          * This is no longer a handle based call.
3842          */
3843         return setxattr(fsp->fsp_name->base_name, name, value, size, flags);
3844 }
3845
3846 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
3847 {
3848         return false;
3849 }
3850
3851 static bool vfswrap_is_offline(struct connection_struct *conn,
3852                                const struct smb_filename *fname)
3853 {
3854         NTSTATUS status;
3855         char *path;
3856         bool offline = false;
3857
3858         if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
3859                 return false;
3860         }
3861
3862         if (!lp_dmapi_support(SNUM(conn)) || !dmapi_have_session()) {
3863 #if defined(ENOTSUP)
3864                 errno = ENOTSUP;
3865 #endif
3866                 return false;
3867         }
3868
3869         status = get_full_smb_filename(talloc_tos(), fname, &path);
3870         if (!NT_STATUS_IS_OK(status)) {
3871                 errno = map_errno_from_nt_status(status);
3872                 return false;
3873         }
3874
3875         offline = (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
3876
3877         TALLOC_FREE(path);
3878
3879         return offline;
3880 }
3881
3882 static NTSTATUS vfswrap_durable_cookie(struct vfs_handle_struct *handle,
3883                                        struct files_struct *fsp,
3884                                        TALLOC_CTX *mem_ctx,
3885                                        DATA_BLOB *cookie)
3886 {
3887         return vfs_default_durable_cookie(fsp, mem_ctx, cookie);
3888 }
3889
3890 static NTSTATUS vfswrap_durable_disconnect(struct vfs_handle_struct *handle,
3891                                            struct files_struct *fsp,
3892                                            const DATA_BLOB old_cookie,
3893                                            TALLOC_CTX *mem_ctx,
3894                                            DATA_BLOB *new_cookie)
3895 {
3896         return vfs_default_durable_disconnect(fsp, old_cookie, mem_ctx,
3897                                               new_cookie);
3898 }
3899
3900 static NTSTATUS vfswrap_durable_reconnect(struct vfs_handle_struct *handle,
3901                                           struct smb_request *smb1req,
3902                                           struct smbXsrv_open *op,
3903                                           const DATA_BLOB old_cookie,
3904                                           TALLOC_CTX *mem_ctx,
3905                                           struct files_struct **fsp,
3906                                           DATA_BLOB *new_cookie)
3907 {
3908         return vfs_default_durable_reconnect(handle->conn, smb1req, op,
3909                                              old_cookie, mem_ctx,
3910                                              fsp, new_cookie);
3911 }
3912
3913 static struct vfs_fn_pointers vfs_default_fns = {
3914         /* Disk operations */
3915
3916         .connect_fn = vfswrap_connect,
3917         .disconnect_fn = vfswrap_disconnect,
3918         .disk_free_fn = vfswrap_disk_free,
3919         .get_quota_fn = vfswrap_get_quota,
3920         .set_quota_fn = vfswrap_set_quota,
3921         .get_shadow_copy_data_fn = vfswrap_get_shadow_copy_data,
3922         .statvfs_fn = vfswrap_statvfs,
3923         .fs_capabilities_fn = vfswrap_fs_capabilities,
3924         .get_dfs_referrals_fn = vfswrap_get_dfs_referrals,
3925         .create_dfs_pathat_fn = vfswrap_create_dfs_pathat,
3926         .read_dfs_pathat_fn = vfswrap_read_dfs_pathat,
3927         .snap_check_path_fn = vfswrap_snap_check_path,
3928         .snap_create_fn = vfswrap_snap_create,
3929         .snap_delete_fn = vfswrap_snap_delete,
3930
3931         /* Directory operations */
3932
3933         .fdopendir_fn = vfswrap_fdopendir,
3934         .readdir_fn = vfswrap_readdir,
3935         .freaddir_attr_fn = vfswrap_freaddir_attr,
3936         .seekdir_fn = vfswrap_seekdir,
3937         .telldir_fn = vfswrap_telldir,
3938         .rewind_dir_fn = vfswrap_rewinddir,
3939         .mkdirat_fn = vfswrap_mkdirat,
3940         .closedir_fn = vfswrap_closedir,
3941
3942         /* File operations */
3943
3944         .openat_fn = vfswrap_openat,
3945         .create_file_fn = vfswrap_create_file,
3946         .close_fn = vfswrap_close,
3947         .pread_fn = vfswrap_pread,
3948         .pread_send_fn = vfswrap_pread_send,
3949         .pread_recv_fn = vfswrap_pread_recv,
3950         .pwrite_fn = vfswrap_pwrite,
3951         .pwrite_send_fn = vfswrap_pwrite_send,
3952         .pwrite_recv_fn = vfswrap_pwrite_recv,
3953         .lseek_fn = vfswrap_lseek,
3954         .sendfile_fn = vfswrap_sendfile,
3955         .recvfile_fn = vfswrap_recvfile,
3956         .renameat_fn = vfswrap_renameat,
3957         .fsync_send_fn = vfswrap_fsync_send,
3958         .fsync_recv_fn = vfswrap_fsync_recv,
3959         .stat_fn = vfswrap_stat,
3960         .fstat_fn = vfswrap_fstat,
3961         .lstat_fn = vfswrap_lstat,
3962         .get_alloc_size_fn = vfswrap_get_alloc_size,
3963         .unlinkat_fn = vfswrap_unlinkat,
3964         .fchmod_fn = vfswrap_fchmod,
3965         .fchown_fn = vfswrap_fchown,
3966         .lchown_fn = vfswrap_lchown,
3967         .chdir_fn = vfswrap_chdir,
3968         .getwd_fn = vfswrap_getwd,
3969         .fntimes_fn = vfswrap_fntimes,
3970         .ftruncate_fn = vfswrap_ftruncate,
3971         .fallocate_fn = vfswrap_fallocate,
3972         .lock_fn = vfswrap_lock,
3973         .kernel_flock_fn = vfswrap_kernel_flock,
3974         .fcntl_fn = vfswrap_fcntl,
3975         .linux_setlease_fn = vfswrap_linux_setlease,
3976         .getlock_fn = vfswrap_getlock,
3977         .symlinkat_fn = vfswrap_symlinkat,
3978         .readlinkat_fn = vfswrap_readlinkat,
3979         .linkat_fn = vfswrap_linkat,
3980         .mknodat_fn = vfswrap_mknodat,
3981         .realpath_fn = vfswrap_realpath,
3982         .fchflags_fn = vfswrap_fchflags,
3983         .file_id_create_fn = vfswrap_file_id_create,
3984         .fs_file_id_fn = vfswrap_fs_file_id,
3985         .fstreaminfo_fn = vfswrap_fstreaminfo,
3986         .get_real_filename_fn = vfswrap_get_real_filename,
3987         .connectpath_fn = vfswrap_connectpath,
3988         .brl_lock_windows_fn = vfswrap_brl_lock_windows,
3989         .brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
3990         .strict_lock_check_fn = vfswrap_strict_lock_check,
3991         .translate_name_fn = vfswrap_translate_name,
3992         .parent_pathname_fn = vfswrap_parent_pathname,
3993         .fsctl_fn = vfswrap_fsctl,
3994         .fset_dos_attributes_fn = vfswrap_fset_dos_attributes,
3995         .get_dos_attributes_send_fn = vfswrap_get_dos_attributes_send,
3996         .get_dos_attributes_recv_fn = vfswrap_get_dos_attributes_recv,
3997         .fget_dos_attributes_fn = vfswrap_fget_dos_attributes,
3998         .offload_read_send_fn = vfswrap_offload_read_send,
3999         .offload_read_recv_fn = vfswrap_offload_read_recv,
4000         .offload_write_send_fn = vfswrap_offload_write_send,
4001         .offload_write_recv_fn = vfswrap_offload_write_recv,
4002         .fget_compression_fn = vfswrap_fget_compression,
4003         .set_compression_fn = vfswrap_set_compression,
4004
4005         /* NT ACL operations. */
4006
4007         .fget_nt_acl_fn = vfswrap_fget_nt_acl,
4008         .fset_nt_acl_fn = vfswrap_fset_nt_acl,
4009         .audit_file_fn = vfswrap_audit_file,
4010
4011         /* POSIX ACL operations. */
4012
4013         .sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd,
4014         .sys_acl_blob_get_fd_fn = posix_sys_acl_blob_get_fd,
4015         .sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd,
4016         .sys_acl_delete_def_fd_fn = vfswrap_sys_acl_delete_def_fd,
4017
4018         /* EA operations. */
4019         .getxattrat_send_fn = vfswrap_getxattrat_send,
4020         .getxattrat_recv_fn = vfswrap_getxattrat_recv,
4021         .fgetxattr_fn = vfswrap_fgetxattr,
4022         .flistxattr_fn = vfswrap_flistxattr,
4023         .fremovexattr_fn = vfswrap_fremovexattr,
4024         .fsetxattr_fn = vfswrap_fsetxattr,
4025
4026         /* aio operations */
4027         .aio_force_fn = vfswrap_aio_force,
4028
4029         /* durable handle operations */
4030         .durable_cookie_fn = vfswrap_durable_cookie,
4031         .durable_disconnect_fn = vfswrap_durable_disconnect,
4032         .durable_reconnect_fn = vfswrap_durable_reconnect,
4033 };
4034
4035 static_decl_vfs;
4036 NTSTATUS vfs_default_init(TALLOC_CTX *ctx)
4037 {
4038         /*
4039          * Here we need to implement every call!
4040          *
4041          * As this is the end of the vfs module chain.
4042          */
4043         smb_vfs_assert_all_fns(&vfs_default_fns, DEFAULT_VFS_MODULE_NAME);
4044         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
4045                                 DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
4046 }
4047
4048