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/asys/asys.h"
  34
  35 #undef DBGC_CLASS
  36 #define DBGC_CLASS DBGC_VFS
  37
  38 /* Check for NULL pointer parameters in vfswrap_* functions */
  39
  40 /* We don't want to have NULL function pointers lying around.  Someone
  41    is sure to try and execute them.  These stubs are used to prevent
  42    this possibility. */
  43
  44 static int vfswrap_connect(vfs_handle_struct *handle,  const char *service, const char *user)
  45 {
  46     return 0;    /* Return >= 0 for success */
  47 }
  48
  49 static void vfswrap_disconnect(vfs_handle_struct *handle)
  50 {
  51 }
  52
  53 /* Disk operations */
  54
  55 static uint64_t vfswrap_disk_free(vfs_handle_struct *handle,  const char *path, bool small_query, uint64_t *bsize,
  56                                uint64_t *dfree, uint64_t *dsize)
  57 {
  58         uint64_t result;
  59
  60         result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
  61         return result;
  62 }
  63
  64 static int vfswrap_get_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  65 {
  66 #ifdef HAVE_SYS_QUOTAS
  67         int result;
  68
  69         START_PROFILE(syscall_get_quota);
  70         result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
  71         END_PROFILE(syscall_get_quota);
  72         return result;
  73 #else
  74         errno = ENOSYS;
  75         return -1;
  76 #endif
  77 }
  78
  79 static int vfswrap_set_quota(struct vfs_handle_struct *handle,  enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
  80 {
  81 #ifdef HAVE_SYS_QUOTAS
  82         int result;
  83
  84         START_PROFILE(syscall_set_quota);
  85         result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
  86         END_PROFILE(syscall_set_quota);
  87         return result;
  88 #else
  89         errno = ENOSYS;
  90         return -1;
  91 #endif
  92 }
  93
  94 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle,
  95                                         struct files_struct *fsp,
  96                                         struct shadow_copy_data *shadow_copy_data,
  97                                         bool labels)
  98 {
  99         errno = ENOSYS;
 100         return -1;  /* Not implemented. */
 101 }
 102
 103 static int vfswrap_statvfs(struct vfs_handle_struct *handle,  const char *path, vfs_statvfs_struct *statbuf)
 104 {
 105         return sys_statvfs(path, statbuf);
 106 }
 107
 108 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct *handle,
 109                 enum timestamp_set_resolution *p_ts_res)
 110 {
 111         connection_struct *conn = handle->conn;
 112         uint32_t caps = FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES;
 113         struct smb_filename *smb_fname_cpath = NULL;
 114         struct vfs_statvfs_struct statbuf;
 115         NTSTATUS status;
 116         int ret;
 117
 118         ZERO_STRUCT(statbuf);
 119         ret = sys_statvfs(conn->connectpath, &statbuf);
 120         if (ret == 0) {
 121                 caps = statbuf.FsCapabilities;
 122         }
 123
 124         *p_ts_res = TIMESTAMP_SET_SECONDS;
 125
 126         /* Work out what timestamp resolution we can
 127          * use when setting a timestamp. */
 128
 129         status = create_synthetic_smb_fname(talloc_tos(),
 130                                 conn->connectpath,
 131                                 NULL,
 132                                 NULL,
 133                                 &smb_fname_cpath);
 134         if (!NT_STATUS_IS_OK(status)) {
 135                 return caps;
 136         }
 137
 138         ret = SMB_VFS_STAT(conn, smb_fname_cpath);
 139         if (ret == -1) {
 140                 TALLOC_FREE(smb_fname_cpath);
 141                 return caps;
 142         }
 143
 144         if (smb_fname_cpath->st.st_ex_mtime.tv_nsec ||
 145                         smb_fname_cpath->st.st_ex_atime.tv_nsec ||
 146                         smb_fname_cpath->st.st_ex_ctime.tv_nsec) {
 147                 /* If any of the normal UNIX directory timestamps
 148                  * have a non-zero tv_nsec component assume
 149                  * we might be able to set sub-second timestamps.
 150                  * See what filetime set primitives we have.
 151                  */
 152 #if defined(HAVE_UTIMENSAT)
 153                 *p_ts_res = TIMESTAMP_SET_NT_OR_BETTER;
 154 #elif defined(HAVE_UTIMES)
 155                 /* utimes allows msec timestamps to be set. */
 156                 *p_ts_res = TIMESTAMP_SET_MSEC;
 157 #elif defined(HAVE_UTIME)
 158                 /* utime only allows sec timestamps to be set. */
 159                 *p_ts_res = TIMESTAMP_SET_SECONDS;
 160 #endif
 161
 162                 DEBUG(10,("vfswrap_fs_capabilities: timestamp "
 163                         "resolution of %s "
 164                         "available on share %s, directory %s\n",
 165                         *p_ts_res == TIMESTAMP_SET_MSEC ? "msec" : "sec",
 166                         lp_servicename(talloc_tos(), conn->params->service),
 167                         conn->connectpath ));
 168         }
 169         TALLOC_FREE(smb_fname_cpath);
 170         return caps;
 171 }
 172
 173 static NTSTATUS vfswrap_get_dfs_referrals(struct vfs_handle_struct *handle,
 174                                           struct dfs_GetDFSReferral *r)
 175 {
 176         struct junction_map *junction = NULL;
 177         int consumedcnt = 0;
 178         bool self_referral = false;
 179         char *pathnamep = NULL;
 180         char *local_dfs_path = NULL;
 181         NTSTATUS status;
 182         int i;
 183         uint16_t max_referral_level = r->in.req.max_referral_level;
 184
 185         if (DEBUGLVL(10)) {
 186                 NDR_PRINT_IN_DEBUG(dfs_GetDFSReferral, r);
 187         }
 188
 189         /* get the junction entry */
 190         if (r->in.req.servername == NULL) {
 191                 return NT_STATUS_NOT_FOUND;
 192         }
 193
 194         /*
 195          * Trim pathname sent by client so it begins with only one backslash.
 196          * Two backslashes confuse some dfs clients
 197          */
 198
 199         local_dfs_path = talloc_strdup(r, r->in.req.servername);
 200         if (local_dfs_path == NULL) {
 201                 return NT_STATUS_NO_MEMORY;
 202         }
 203         pathnamep = local_dfs_path;
 204         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
 205                IS_DIRECTORY_SEP(pathnamep[1])) {
 206                 pathnamep++;
 207         }
 208
 209         junction = talloc_zero(r, struct junction_map);
 210         if (junction == NULL) {
 211                 return NT_STATUS_NO_MEMORY;
 212         }
 213
 214         /* The following call can change cwd. */
 215         status = get_referred_path(r, pathnamep,
 216                                    !handle->conn->sconn->using_smb2,
 217                                    junction, &consumedcnt, &self_referral);
 218         if (!NT_STATUS_IS_OK(status)) {
 219                 vfs_ChDir(handle->conn, handle->conn->connectpath);
 220                 return status;
 221         }
 222         vfs_ChDir(handle->conn, handle->conn->connectpath);
 223
 224         if (!self_referral) {
 225                 pathnamep[consumedcnt] = '\0';
 226
 227                 if (DEBUGLVL(3)) {
 228                         dbgtext("setup_dfs_referral: Path %s to "
 229                                 "alternate path(s):",
 230                                 pathnamep);
 231                         for (i=0; i < junction->referral_count; i++) {
 232                                 dbgtext(" %s",
 233                                 junction->referral_list[i].alternate_path);
 234                         }
 235                         dbgtext(".\n");
 236                 }
 237         }
 238
 239         if (r->in.req.max_referral_level <= 2) {
 240                 max_referral_level = 2;
 241         }
 242         if (r->in.req.max_referral_level >= 3) {
 243                 max_referral_level = 3;
 244         }
 245
 246         r->out.resp = talloc_zero(r, struct dfs_referral_resp);
 247         if (r->out.resp == NULL) {
 248                 return NT_STATUS_NO_MEMORY;
 249         }
 250
 251         r->out.resp->path_consumed = strlen_m(pathnamep) * 2;
 252         r->out.resp->nb_referrals = junction->referral_count;
 253
 254         r->out.resp->header_flags = DFS_HEADER_FLAG_STORAGE_SVR;
 255         if (self_referral) {
 256                 r->out.resp->header_flags |= DFS_HEADER_FLAG_REFERAL_SVR;
 257         }
 258
 259         r->out.resp->referral_entries = talloc_zero_array(r,
 260                                 struct dfs_referral_type,
 261                                 r->out.resp->nb_referrals);
 262         if (r->out.resp->referral_entries == NULL) {
 263                 return NT_STATUS_NO_MEMORY;
 264         }
 265
 266         switch (max_referral_level) {
 267         case 2:
 268                 for(i=0; i < junction->referral_count; i++) {
 269                         struct referral *ref = &junction->referral_list[i];
 270                         TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
 271                         struct dfs_referral_type *t =
 272                                 &r->out.resp->referral_entries[i];
 273                         struct dfs_referral_v2 *v2 = &t->referral.v2;
 274
 275                         t->version = 2;
 276                         v2->size = VERSION2_REFERRAL_SIZE;
 277                         if (self_referral) {
 278                                 v2->server_type = DFS_SERVER_ROOT;
 279                         } else {
 280                                 v2->server_type = DFS_SERVER_NON_ROOT;
 281                         }
 282                         v2->entry_flags = 0;
 283                         v2->proximity = ref->proximity;
 284                         v2->ttl = ref->ttl;
 285                         v2->DFS_path = talloc_strdup(mem_ctx, pathnamep);
 286                         if (v2->DFS_path == NULL) {
 287                                 return NT_STATUS_NO_MEMORY;
 288                         }
 289                         v2->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
 290                         if (v2->DFS_alt_path == NULL) {
 291                                 return NT_STATUS_NO_MEMORY;
 292                         }
 293                         v2->netw_address = talloc_strdup(mem_ctx,
 294                                                          ref->alternate_path);
 295                         if (v2->netw_address == NULL) {
 296                                 return NT_STATUS_NO_MEMORY;
 297                         }
 298                 }
 299
 300                 break;
 301         case 3:
 302                 for(i=0; i < junction->referral_count; i++) {
 303                         struct referral *ref = &junction->referral_list[i];
 304                         TALLOC_CTX *mem_ctx = r->out.resp->referral_entries;
 305                         struct dfs_referral_type *t =
 306                                 &r->out.resp->referral_entries[i];
 307                         struct dfs_referral_v3 *v3 = &t->referral.v3;
 308                         struct dfs_normal_referral *r1 = &v3->referrals.r1;
 309
 310                         t->version = 3;
 311                         v3->size = VERSION3_REFERRAL_SIZE;
 312                         if (self_referral) {
 313                                 v3->server_type = DFS_SERVER_ROOT;
 314                         } else {
 315                                 v3->server_type = DFS_SERVER_NON_ROOT;
 316                         }
 317                         v3->entry_flags = 0;
 318                         v3->ttl = ref->ttl;
 319                         r1->DFS_path = talloc_strdup(mem_ctx, pathnamep);
 320                         if (r1->DFS_path == NULL) {
 321                                 return NT_STATUS_NO_MEMORY;
 322                         }
 323                         r1->DFS_alt_path = talloc_strdup(mem_ctx, pathnamep);
 324                         if (r1->DFS_alt_path == NULL) {
 325                                 return NT_STATUS_NO_MEMORY;
 326                         }
 327                         r1->netw_address = talloc_strdup(mem_ctx,
 328                                                          ref->alternate_path);
 329                         if (r1->netw_address == NULL) {
 330                                 return NT_STATUS_NO_MEMORY;
 331                         }
 332                 }
 333                 break;
 334         default:
 335                 DEBUG(0,("setup_dfs_referral: Invalid dfs referral "
 336                         "version: %d\n",
 337                         max_referral_level));
 338                 return NT_STATUS_INVALID_LEVEL;
 339         }
 340
 341         if (DEBUGLVL(10)) {
 342                 NDR_PRINT_OUT_DEBUG(dfs_GetDFSReferral, r);
 343         }
 344
 345         return NT_STATUS_OK;
 346 }
 347
 348 /* Directory operations */
 349
 350 static DIR *vfswrap_opendir(vfs_handle_struct *handle,  const char *fname, const char *mask, uint32 attr)
 351 {
 352         DIR *result;
 353
 354         START_PROFILE(syscall_opendir);
 355         result = opendir(fname);
 356         END_PROFILE(syscall_opendir);
 357         return result;
 358 }
 359
 360 static DIR *vfswrap_fdopendir(vfs_handle_struct *handle,
 361                         files_struct *fsp,
 362                         const char *mask,
 363                         uint32 attr)
 364 {
 365         DIR *result;
 366
 367         START_PROFILE(syscall_fdopendir);
 368         result = sys_fdopendir(fsp->fh->fd);
 369         END_PROFILE(syscall_fdopendir);
 370         return result;
 371 }
 372
 373
 374 static struct dirent *vfswrap_readdir(vfs_handle_struct *handle,
 375                                           DIR *dirp,
 376                                           SMB_STRUCT_STAT *sbuf)
 377 {
 378         struct dirent *result;
 379
 380         START_PROFILE(syscall_readdir);
 381         result = readdir(dirp);
 382         /* Default Posix readdir() does not give us stat info.
 383          * Set to invalid to indicate we didn't return this info. */
 384         if (sbuf)
 385                 SET_STAT_INVALID(*sbuf);
 386         END_PROFILE(syscall_readdir);
 387         return result;
 388 }
 389
 390 static void vfswrap_seekdir(vfs_handle_struct *handle,  DIR *dirp, long offset)
 391 {
 392         START_PROFILE(syscall_seekdir);
 393         seekdir(dirp, offset);
 394         END_PROFILE(syscall_seekdir);
 395 }
 396
 397 static long vfswrap_telldir(vfs_handle_struct *handle,  DIR *dirp)
 398 {
 399         long result;
 400         START_PROFILE(syscall_telldir);
 401         result = telldir(dirp);
 402         END_PROFILE(syscall_telldir);
 403         return result;
 404 }
 405
 406 static void vfswrap_rewinddir(vfs_handle_struct *handle,  DIR *dirp)
 407 {
 408         START_PROFILE(syscall_rewinddir);
 409         rewinddir(dirp);
 410         END_PROFILE(syscall_rewinddir);
 411 }
 412
 413 static int vfswrap_mkdir(vfs_handle_struct *handle,  const char *path, mode_t mode)
 414 {
 415         int result;
 416         bool has_dacl = False;
 417         char *parent = NULL;
 418
 419         START_PROFILE(syscall_mkdir);
 420
 421         if (lp_inherit_acls(SNUM(handle->conn))
 422             && parent_dirname(talloc_tos(), path, &parent, NULL)
 423             && (has_dacl = directory_has_default_acl(handle->conn, parent)))
 424                 mode = (0777 & lp_dir_mask(SNUM(handle->conn)));
 425
 426         TALLOC_FREE(parent);
 427
 428         result = mkdir(path, mode);
 429
 430         if (result == 0 && !has_dacl) {
 431                 /*
 432                  * We need to do this as the default behavior of POSIX ACLs
 433                  * is to set the mask to be the requested group permission
 434                  * bits, not the group permission bits to be the requested
 435                  * group permission bits. This is not what we want, as it will
 436                  * mess up any inherited ACL bits that were set. JRA.
 437                  */
 438                 int saved_errno = errno; /* We may get ENOSYS */
 439                 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
 440                         errno = saved_errno;
 441         }
 442
 443         END_PROFILE(syscall_mkdir);
 444         return result;
 445 }
 446
 447 static int vfswrap_rmdir(vfs_handle_struct *handle,  const char *path)
 448 {
 449         int result;
 450
 451         START_PROFILE(syscall_rmdir);
 452         result = rmdir(path);
 453         END_PROFILE(syscall_rmdir);
 454         return result;
 455 }
 456
 457 static int vfswrap_closedir(vfs_handle_struct *handle,  DIR *dirp)
 458 {
 459         int result;
 460
 461         START_PROFILE(syscall_closedir);
 462         result = closedir(dirp);
 463         END_PROFILE(syscall_closedir);
 464         return result;
 465 }
 466
 467 static void vfswrap_init_search_op(vfs_handle_struct *handle,
 468                                    DIR *dirp)
 469 {
 470         /* Default behavior is a NOOP */
 471 }
 472
 473 /* File operations */
 474
 475 static int vfswrap_open(vfs_handle_struct *handle,
 476                         struct smb_filename *smb_fname,
 477                         files_struct *fsp, int flags, mode_t mode)
 478 {
 479         int result = -1;
 480
 481         START_PROFILE(syscall_open);
 482
 483         if (smb_fname->stream_name) {
 484                 errno = ENOENT;
 485                 goto out;
 486         }
 487
 488         result = open(smb_fname->base_name, flags, mode);
 489  out:
 490         END_PROFILE(syscall_open);
 491         return result;
 492 }
 493
 494 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
 495                                     struct smb_request *req,
 496                                     uint16_t root_dir_fid,
 497                                     struct smb_filename *smb_fname,
 498                                     uint32_t access_mask,
 499                                     uint32_t share_access,
 500                                     uint32_t create_disposition,
 501                                     uint32_t create_options,
 502                                     uint32_t file_attributes,
 503                                     uint32_t oplock_request,
 504                                     uint64_t allocation_size,
 505                                     uint32_t private_flags,
 506                                     struct security_descriptor *sd,
 507                                     struct ea_list *ea_list,
 508                                     files_struct **result,
 509                                     int *pinfo)
 510 {
 511         return create_file_default(handle->conn, req, root_dir_fid, smb_fname,
 512                                    access_mask, share_access,
 513                                    create_disposition, create_options,
 514                                    file_attributes, oplock_request,
 515                                    allocation_size, private_flags,
 516                                    sd, ea_list, result,
 517                                    pinfo);
 518 }
 519
 520 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
 521 {
 522         int result;
 523
 524         START_PROFILE(syscall_close);
 525         result = fd_close_posix(fsp);
 526         END_PROFILE(syscall_close);
 527         return result;
 528 }
 529
 530 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
 531 {
 532         ssize_t result;
 533
 534         START_PROFILE_BYTES(syscall_read, n);
 535         result = sys_read(fsp->fh->fd, data, n);
 536         END_PROFILE(syscall_read);
 537         return result;
 538 }
 539
 540 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
 541                         size_t n, off_t offset)
 542 {
 543         ssize_t result;
 544
 545 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
 546         START_PROFILE_BYTES(syscall_pread, n);
 547         result = sys_pread(fsp->fh->fd, data, n, offset);
 548         END_PROFILE(syscall_pread);
 549
 550         if (result == -1 && errno == ESPIPE) {
 551                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 552                 result = SMB_VFS_READ(fsp, data, n);
 553                 fsp->fh->pos = 0;
 554         }
 555
 556 #else /* HAVE_PREAD */
 557         off_t   curr;
 558         int lerrno;
 559
 560         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 561         if (curr == -1 && errno == ESPIPE) {
 562                 /* Maintain the fiction that pipes can be seeked (sought?) on. */
 563                 result = SMB_VFS_READ(fsp, data, n);
 564                 fsp->fh->pos = 0;
 565                 return result;
 566         }
 567
 568         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 569                 return -1;
 570         }
 571
 572         errno = 0;
 573         result = SMB_VFS_READ(fsp, data, n);
 574         lerrno = errno;
 575
 576         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 577         errno = lerrno;
 578
 579 #endif /* HAVE_PREAD */
 580
 581         return result;
 582 }
 583
 584 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
 585 {
 586         ssize_t result;
 587
 588         START_PROFILE_BYTES(syscall_write, n);
 589         result = sys_write(fsp->fh->fd, data, n);
 590         END_PROFILE(syscall_write);
 591         return result;
 592 }
 593
 594 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
 595                         size_t n, off_t offset)
 596 {
 597         ssize_t result;
 598
 599 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
 600         START_PROFILE_BYTES(syscall_pwrite, n);
 601         result = sys_pwrite(fsp->fh->fd, data, n, offset);
 602         END_PROFILE(syscall_pwrite);
 603
 604         if (result == -1 && errno == ESPIPE) {
 605                 /* Maintain the fiction that pipes can be sought on. */
 606                 result = SMB_VFS_WRITE(fsp, data, n);
 607         }
 608
 609 #else /* HAVE_PWRITE */
 610         off_t   curr;
 611         int         lerrno;
 612
 613         curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
 614         if (curr == -1) {
 615                 return -1;
 616         }
 617
 618         if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
 619                 return -1;
 620         }
 621
 622         result = SMB_VFS_WRITE(fsp, data, n);
 623         lerrno = errno;
 624
 625         SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
 626         errno = lerrno;
 627
 628 #endif /* HAVE_PWRITE */
 629
 630         return result;
 631 }
 632
 633 static void vfswrap_asys_finished(struct tevent_context *ev,
 634                                   struct tevent_fd *fde,
 635                                   uint16_t flags, void *p);
 636
 637 static bool vfswrap_init_asys_ctx(struct smbXsrv_connection *conn)
 638 {
 639         int ret;
 640         int fd;
 641
 642         if (conn->asys_ctx != NULL) {
 643                 return true;
 644         }
 645         ret = asys_context_init(&conn->asys_ctx, aio_pending_size);
 646         if (ret != 0) {
 647                 DEBUG(1, ("asys_context_init failed: %s\n", strerror(ret)));
 648                 return false;
 649         }
 650
 651         fd = asys_signalfd(conn->asys_ctx);
 652
 653         set_blocking(fd, false);
 654
 655         conn->asys_fde = tevent_add_fd(conn->ev_ctx, conn, fd,
 656                                        TEVENT_FD_READ,
 657                                        vfswrap_asys_finished,
 658                                        conn->asys_ctx);
 659         if (conn->asys_fde == NULL) {
 660                 DEBUG(1, ("tevent_add_fd failed\n"));
 661                 asys_context_destroy(conn->asys_ctx);
 662                 conn->asys_ctx = NULL;
 663                 return false;
 664         }
 665         return true;
 666 }
 667
 668 struct vfswrap_asys_state {
 669         struct asys_context *asys_ctx;
 670         struct tevent_req *req;
 671         ssize_t ret;
 672         int err;
 673 };
 674
 675 static int vfswrap_asys_state_destructor(struct vfswrap_asys_state *s)
 676 {
 677         asys_cancel(s->asys_ctx, s->req);
 678         return 0;
 679 }
 680
 681 static struct tevent_req *vfswrap_pread_send(struct vfs_handle_struct *handle,
 682                                              TALLOC_CTX *mem_ctx,
 683                                              struct tevent_context *ev,
 684                                              struct files_struct *fsp,
 685                                              void *data,
 686                                              size_t n, off_t offset)
 687 {
 688         struct tevent_req *req;
 689         struct vfswrap_asys_state *state;
 690         int ret;
 691
 692         req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
 693         if (req == NULL) {
 694                 return NULL;
 695         }
 696         if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
 697                 tevent_req_oom(req);
 698                 return tevent_req_post(req, ev);
 699         }
 700         state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
 701         state->req = req;
 702
 703         ret = asys_pread(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
 704         if (ret != 0) {
 705                 tevent_req_error(req, ret);
 706                 return tevent_req_post(req, ev);
 707         }
 708         talloc_set_destructor(state, vfswrap_asys_state_destructor);
 709
 710         return req;
 711 }
 712
 713 static struct tevent_req *vfswrap_pwrite_send(struct vfs_handle_struct *handle,
 714                                               TALLOC_CTX *mem_ctx,
 715                                               struct tevent_context *ev,
 716                                               struct files_struct *fsp,
 717                                               const void *data,
 718                                               size_t n, off_t offset)
 719 {
 720         struct tevent_req *req;
 721         struct vfswrap_asys_state *state;
 722         int ret;
 723
 724         req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
 725         if (req == NULL) {
 726                 return NULL;
 727         }
 728         if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
 729                 tevent_req_oom(req);
 730                 return tevent_req_post(req, ev);
 731         }
 732         state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
 733         state->req = req;
 734
 735         ret = asys_pwrite(state->asys_ctx, fsp->fh->fd, data, n, offset, req);
 736         if (ret != 0) {
 737                 tevent_req_error(req, ret);
 738                 return tevent_req_post(req, ev);
 739         }
 740         talloc_set_destructor(state, vfswrap_asys_state_destructor);
 741
 742         return req;
 743 }
 744
 745 static struct tevent_req *vfswrap_fsync_send(struct vfs_handle_struct *handle,
 746                                              TALLOC_CTX *mem_ctx,
 747                                              struct tevent_context *ev,
 748                                              struct files_struct *fsp)
 749 {
 750         struct tevent_req *req;
 751         struct vfswrap_asys_state *state;
 752         int ret;
 753
 754         req = tevent_req_create(mem_ctx, &state, struct vfswrap_asys_state);
 755         if (req == NULL) {
 756                 return NULL;
 757         }
 758         if (!vfswrap_init_asys_ctx(handle->conn->sconn->conn)) {
 759                 tevent_req_oom(req);
 760                 return tevent_req_post(req, ev);
 761         }
 762         state->asys_ctx = handle->conn->sconn->conn->asys_ctx;
 763         state->req = req;
 764
 765         ret = asys_fsync(state->asys_ctx, fsp->fh->fd, req);
 766         if (ret != 0) {
 767                 tevent_req_error(req, ret);
 768                 return tevent_req_post(req, ev);
 769         }
 770         talloc_set_destructor(state, vfswrap_asys_state_destructor);
 771
 772         return req;
 773 }
 774
 775 static void vfswrap_asys_finished(struct tevent_context *ev,
 776                                         struct tevent_fd *fde,
 777                                         uint16_t flags, void *p)
 778 {
 779         struct asys_context *asys_ctx = (struct asys_context *)p;
 780         struct tevent_req *req;
 781         struct vfswrap_asys_state *state;
 782         int res;
 783         ssize_t ret;
 784         int err;
 785         void *private_data;
 786
 787         if ((flags & TEVENT_FD_READ) == 0) {
 788                 return;
 789         }
 790
 791         while (true) {
 792                 res = asys_result(asys_ctx, &ret, &err, &private_data);
 793                 if (res == EINTR || res == EAGAIN) {
 794                         return;
 795                 }
 796 #ifdef EWOULDBLOCK
 797                 if (res == EWOULDBLOCK) {
 798                         return;
 799                 }
 800 #endif
 801
 802                 if (res == ECANCELED) {
 803                         return;
 804                 }
 805
 806                 if (res != 0) {
 807                         DEBUG(1, ("asys_result returned %s\n", strerror(res)));
 808                         return;
 809                 }
 810
 811                 req = talloc_get_type_abort(private_data, struct tevent_req);
 812                 state = tevent_req_data(req, struct vfswrap_asys_state);
 813
 814                 talloc_set_destructor(state, NULL);
 815
 816                 state->ret = ret;
 817                 state->err = err;
 818                 tevent_req_defer_callback(req, ev);
 819                 tevent_req_done(req);
 820         }
 821 }
 822
 823 static ssize_t vfswrap_asys_ssize_t_recv(struct tevent_req *req, int *err)
 824 {
 825         struct vfswrap_asys_state *state = tevent_req_data(
 826                 req, struct vfswrap_asys_state);
 827
 828         if (tevent_req_is_unix_error(req, err)) {
 829                 return -1;
 830         }
 831         *err = state->err;
 832         return state->ret;
 833 }
 834
 835 static int vfswrap_asys_int_recv(struct tevent_req *req, int *err)
 836 {
 837         struct vfswrap_asys_state *state = tevent_req_data(
 838                 req, struct vfswrap_asys_state);
 839
 840         if (tevent_req_is_unix_error(req, err)) {
 841                 return -1;
 842         }
 843         *err = state->err;
 844         return state->ret;
 845 }
 846
 847 static off_t vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, off_t offset, int whence)
 848 {
 849         off_t result = 0;
 850
 851         START_PROFILE(syscall_lseek);
 852
 853         /* Cope with 'stat' file opens. */
 854         if (fsp->fh->fd != -1)
 855                 result = lseek(fsp->fh->fd, offset, whence);
 856
 857         /*
 858          * We want to maintain the fiction that we can seek
 859          * on a fifo for file system purposes. This allows
 860          * people to set up UNIX fifo's that feed data to Windows
 861          * applications. JRA.
 862          */
 863
 864         if((result == -1) && (errno == ESPIPE)) {
 865                 result = 0;
 866                 errno = 0;
 867         }
 868
 869         END_PROFILE(syscall_lseek);
 870         return result;
 871 }
 872
 873 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
 874                         off_t offset, size_t n)
 875 {
 876         ssize_t result;
 877
 878         START_PROFILE_BYTES(syscall_sendfile, n);
 879         result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
 880         END_PROFILE(syscall_sendfile);
 881         return result;
 882 }
 883
 884 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
 885                         int fromfd,
 886                         files_struct *tofsp,
 887                         off_t offset,
 888                         size_t n)
 889 {
 890         ssize_t result;
 891
 892         START_PROFILE_BYTES(syscall_recvfile, n);
 893         result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
 894         END_PROFILE(syscall_recvfile);
 895         return result;
 896 }
 897
 898 static int vfswrap_rename(vfs_handle_struct *handle,
 899                           const struct smb_filename *smb_fname_src,
 900                           const struct smb_filename *smb_fname_dst)
 901 {
 902         int result = -1;
 903
 904         START_PROFILE(syscall_rename);
 905
 906         if (smb_fname_src->stream_name || smb_fname_dst->stream_name) {
 907                 errno = ENOENT;
 908                 goto out;
 909         }
 910
 911         result = rename(smb_fname_src->base_name, smb_fname_dst->base_name);
 912
 913  out:
 914         END_PROFILE(syscall_rename);
 915         return result;
 916 }
 917
 918 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
 919 {
 920 #ifdef HAVE_FSYNC
 921         int result;
 922
 923         START_PROFILE(syscall_fsync);
 924         result = fsync(fsp->fh->fd);
 925         END_PROFILE(syscall_fsync);
 926         return result;
 927 #else
 928         return 0;
 929 #endif
 930 }
 931
 932 static int vfswrap_stat(vfs_handle_struct *handle,
 933                         struct smb_filename *smb_fname)
 934 {
 935         int result = -1;
 936
 937         START_PROFILE(syscall_stat);
 938
 939         if (smb_fname->stream_name) {
 940                 errno = ENOENT;
 941                 goto out;
 942         }
 943
 944         result = sys_stat(smb_fname->base_name, &smb_fname->st,
 945                           lp_fake_dir_create_times(SNUM(handle->conn)));
 946  out:
 947         END_PROFILE(syscall_stat);
 948         return result;
 949 }
 950
 951 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
 952 {
 953         int result;
 954
 955         START_PROFILE(syscall_fstat);
 956         result = sys_fstat(fsp->fh->fd,
 957                            sbuf, lp_fake_dir_create_times(SNUM(handle->conn)));
 958         END_PROFILE(syscall_fstat);
 959         return result;
 960 }
 961
 962 static int vfswrap_lstat(vfs_handle_struct *handle,
 963                          struct smb_filename *smb_fname)
 964 {
 965         int result = -1;
 966
 967         START_PROFILE(syscall_lstat);
 968
 969         if (smb_fname->stream_name) {
 970                 errno = ENOENT;
 971                 goto out;
 972         }
 973
 974         result = sys_lstat(smb_fname->base_name, &smb_fname->st,
 975                            lp_fake_dir_create_times(SNUM(handle->conn)));
 976  out:
 977         END_PROFILE(syscall_lstat);
 978         return result;
 979 }
 980
 981 static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
 982                                        const char *name,
 983                                        enum vfs_translate_direction direction,
 984                                        TALLOC_CTX *mem_ctx,
 985                                        char **mapped_name)
 986 {
 987         return NT_STATUS_NONE_MAPPED;
 988 }
 989
 990 /*
 991  * Implement the default fsctl operation.
 992  */
 993 static bool vfswrap_logged_ioctl_message = false;
 994
 995 static NTSTATUS vfswrap_fsctl(struct vfs_handle_struct *handle,
 996                               struct files_struct *fsp,
 997                               TALLOC_CTX *ctx,
 998                               uint32_t function,
 999                               uint16_t req_flags,  /* Needed for UNICODE ... */
1000                               const uint8_t *_in_data,
1001                               uint32_t in_len,
1002                               uint8_t **_out_data,
1003                               uint32_t max_out_len,
1004                               uint32_t *out_len)
1005 {
1006         const char *in_data = (const char *)_in_data;
1007         char **out_data = (char **)_out_data;
1008
1009         switch (function) {
1010         case FSCTL_SET_SPARSE:
1011         {
1012                 bool set_sparse = true;
1013                 NTSTATUS status;
1014
1015                 if (in_len >= 1 && in_data[0] == 0) {
1016                         set_sparse = false;
1017                 }
1018
1019                 status = file_set_sparse(handle->conn, fsp, set_sparse);
1020
1021                 DEBUG(NT_STATUS_IS_OK(status) ? 10 : 9,
1022                       ("FSCTL_SET_SPARSE: fname[%s] set[%u] - %s\n",
1023                        smb_fname_str_dbg(fsp->fsp_name), set_sparse,
1024                        nt_errstr(status)));
1025
1026                 return status;
1027         }
1028
1029         case FSCTL_CREATE_OR_GET_OBJECT_ID:
1030         {
1031                 unsigned char objid[16];
1032                 char *return_data = NULL;
1033
1034                 /* This should return the object-id on this file.
1035                  * I think I'll make this be the inode+dev. JRA.
1036                  */
1037
1038                 DEBUG(10,("FSCTL_CREATE_OR_GET_OBJECT_ID: called on %s\n",
1039                           fsp_fnum_dbg(fsp)));
1040
1041                 *out_len = (max_out_len >= 64) ? 64 : max_out_len;
1042                 /* Hmmm, will this cause problems if less data asked for? */
1043                 return_data = talloc_array(ctx, char, 64);
1044                 if (return_data == NULL) {
1045                         return NT_STATUS_NO_MEMORY;
1046                 }
1047
1048                 /* For backwards compatibility only store the dev/inode. */
1049                 push_file_id_16(return_data, &fsp->file_id);
1050                 memcpy(return_data+16,create_volume_objectid(fsp->conn,objid),16);
1051                 push_file_id_16(return_data+32, &fsp->file_id);
1052                 *out_data = return_data;
1053                 return NT_STATUS_OK;
1054         }
1055
1056         case FSCTL_GET_REPARSE_POINT:
1057         {
1058                 /* Fail it with STATUS_NOT_A_REPARSE_POINT */
1059                 DEBUG(10, ("FSCTL_GET_REPARSE_POINT: called on %s. "
1060                            "Status: NOT_IMPLEMENTED\n", fsp_fnum_dbg(fsp)));
1061                 return NT_STATUS_NOT_A_REPARSE_POINT;
1062         }
1063
1064         case FSCTL_SET_REPARSE_POINT:
1065         {
1066                 /* Fail it with STATUS_NOT_A_REPARSE_POINT */
1067                 DEBUG(10, ("FSCTL_SET_REPARSE_POINT: called on %s. "
1068                            "Status: NOT_IMPLEMENTED\n", fsp_fnum_dbg(fsp)));
1069                 return NT_STATUS_NOT_A_REPARSE_POINT;
1070         }
1071
1072         case FSCTL_GET_SHADOW_COPY_DATA:
1073         {
1074                 /*
1075                  * This is called to retrieve the number of Shadow Copies (a.k.a. snapshots)
1076                  * and return their volume names.  If max_data_count is 16, then it is just
1077                  * asking for the number of volumes and length of the combined names.
1078                  *
1079                  * pdata is the data allocated by our caller, but that uses
1080                  * total_data_count (which is 0 in our case) rather than max_data_count.
1081                  * Allocate the correct amount and return the pointer to let
1082                  * it be deallocated when we return.
1083                  */
1084                 struct shadow_copy_data *shadow_data = NULL;
1085                 bool labels = False;
1086                 uint32 labels_data_count = 0;
1087                 uint32 i;
1088                 char *cur_pdata = NULL;
1089
1090                 if (max_out_len < 16) {
1091                         DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) < 16 is invalid!\n",
1092                                 max_out_len));
1093                         return NT_STATUS_INVALID_PARAMETER;
1094                 }
1095
1096                 if (max_out_len > 16) {
1097                         labels = True;
1098                 }
1099
1100                 shadow_data = talloc_zero(ctx, struct shadow_copy_data);
1101                 if (shadow_data == NULL) {
1102                         DEBUG(0,("TALLOC_ZERO() failed!\n"));
1103                         return NT_STATUS_NO_MEMORY;
1104                 }
1105
1106                 /*
1107                  * Call the VFS routine to actually do the work.
1108                  */
1109                 if (SMB_VFS_GET_SHADOW_COPY_DATA(fsp, shadow_data, labels)!=0) {
1110                         TALLOC_FREE(shadow_data);
1111                         if (errno == ENOSYS) {
1112                                 DEBUG(5,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, not supported.\n",
1113                                         fsp->conn->connectpath));
1114                                 return NT_STATUS_NOT_SUPPORTED;
1115                         } else {
1116                                 DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: connectpath %s, failed.\n",
1117                                         fsp->conn->connectpath));
1118                                 return NT_STATUS_UNSUCCESSFUL;
1119                         }
1120                 }
1121
1122                 labels_data_count = (shadow_data->num_volumes * 2 *
1123                                         sizeof(SHADOW_COPY_LABEL)) + 2;
1124
1125                 if (!labels) {
1126                         *out_len = 16;
1127                 } else {
1128                         *out_len = 12 + labels_data_count;
1129                 }
1130
1131                 if (max_out_len < *out_len) {
1132                         DEBUG(0,("FSCTL_GET_SHADOW_COPY_DATA: max_data_count(%u) too small (%u) bytes needed!\n",
1133                                 max_out_len, *out_len));
1134                         TALLOC_FREE(shadow_data);
1135                         return NT_STATUS_BUFFER_TOO_SMALL;
1136                 }
1137
1138                 cur_pdata = talloc_zero_array(ctx, char, *out_len);
1139                 if (cur_pdata == NULL) {
1140                         TALLOC_FREE(shadow_data);
1141                         return NT_STATUS_NO_MEMORY;
1142                 }
1143
1144                 *out_data = cur_pdata;
1145
1146                 /* num_volumes 4 bytes */
1147                 SIVAL(cur_pdata, 0, shadow_data->num_volumes);
1148
1149                 if (labels) {
1150                         /* num_labels 4 bytes */
1151                         SIVAL(cur_pdata, 4, shadow_data->num_volumes);
1152                 }
1153
1154                 /* needed_data_count 4 bytes */
1155                 SIVAL(cur_pdata, 8, labels_data_count);
1156
1157                 cur_pdata += 12;
1158
1159                 DEBUG(10,("FSCTL_GET_SHADOW_COPY_DATA: %u volumes for path[%s].\n",
1160                           shadow_data->num_volumes, fsp_str_dbg(fsp)));
1161                 if (labels && shadow_data->labels) {
1162                         for (i=0; i<shadow_data->num_volumes; i++) {
1163                                 srvstr_push(cur_pdata, req_flags,
1164                                             cur_pdata, shadow_data->labels[i],
1165                                             2 * sizeof(SHADOW_COPY_LABEL),
1166                                             STR_UNICODE|STR_TERMINATE);
1167                                 cur_pdata += 2 * sizeof(SHADOW_COPY_LABEL);
1168                                 DEBUGADD(10,("Label[%u]: '%s'\n",i,shadow_data->labels[i]));
1169                         }
1170                 }
1171
1172                 TALLOC_FREE(shadow_data);
1173
1174                 return NT_STATUS_OK;
1175         }
1176
1177         case FSCTL_FIND_FILES_BY_SID:
1178         {
1179                 /* pretend this succeeded -
1180                  *
1181                  * we have to send back a list with all files owned by this SID
1182                  *
1183                  * but I have to check that --metze
1184                  */
1185                 struct dom_sid sid;
1186                 uid_t uid;
1187                 size_t sid_len;
1188
1189                 DEBUG(10, ("FSCTL_FIND_FILES_BY_SID: called on %s\n",
1190                            fsp_fnum_dbg(fsp)));
1191
1192                 if (in_len < 8) {
1193                         /* NT_STATUS_BUFFER_TOO_SMALL maybe? */
1194                         return NT_STATUS_INVALID_PARAMETER;
1195                 }
1196
1197                 sid_len = MIN(in_len - 4,SID_MAX_SIZE);
1198
1199                 /* unknown 4 bytes: this is not the length of the sid :-(  */
1200                 /*unknown = IVAL(pdata,0);*/
1201
1202                 if (!sid_parse(in_data + 4, sid_len, &sid)) {
1203                         return NT_STATUS_INVALID_PARAMETER;
1204                 }
1205                 DEBUGADD(10, ("for SID: %s\n", sid_string_dbg(&sid)));
1206
1207                 if (!sid_to_uid(&sid, &uid)) {
1208                         DEBUG(0,("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
1209                                  sid_string_dbg(&sid),
1210                                  (unsigned long)sid_len));
1211                         uid = (-1);
1212                 }
1213
1214                 /* we can take a look at the find source :-)
1215                  *
1216                  * find ./ -uid $uid  -name '*'   is what we need here
1217                  *
1218                  *
1219                  * and send 4bytes len and then NULL terminated unicode strings
1220                  * for each file
1221                  *
1222                  * but I don't know how to deal with the paged results
1223                  * (maybe we can hang the result anywhere in the fsp struct)
1224                  *
1225                  * but I don't know how to deal with the paged results
1226                  * (maybe we can hang the result anywhere in the fsp struct)
1227                  *
1228                  * we don't send all files at once
1229                  * and at the next we should *not* start from the beginning,
1230                  * so we have to cache the result
1231                  *
1232                  * --metze
1233                  */
1234
1235                 /* this works for now... */
1236                 return NT_STATUS_OK;
1237         }
1238
1239         case FSCTL_QUERY_ALLOCATED_RANGES:
1240         {
1241                 /* FIXME: This is just a dummy reply, telling that all of the
1242                  * file is allocated. MKS cp needs that.
1243                  * Adding the real allocated ranges via FIEMAP on Linux
1244                  * and SEEK_DATA/SEEK_HOLE on Solaris is needed to make
1245                  * this FSCTL correct for sparse files.
1246                  */
1247                 NTSTATUS status;
1248                 uint64_t offset, length;
1249                 char *out_data_tmp = NULL;
1250
1251                 if (in_len != 16) {
1252                         DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: data_count(%u) != 16 is invalid!\n",
1253                                 in_len));
1254                         return NT_STATUS_INVALID_PARAMETER;
1255                 }
1256
1257                 if (max_out_len < 16) {
1258                         DEBUG(0,("FSCTL_QUERY_ALLOCATED_RANGES: max_out_len (%u) < 16 is invalid!\n",
1259                                 max_out_len));
1260                         return NT_STATUS_INVALID_PARAMETER;
1261                 }
1262
1263                 offset = BVAL(in_data,0);
1264                 length = BVAL(in_data,8);
1265
1266                 if (offset + length < offset) {
1267                         /* No 64-bit integer wrap. */
1268                         return NT_STATUS_INVALID_PARAMETER;
1269                 }
1270
1271                 /* Shouldn't this be SMB_VFS_STAT ... ? */
1272                 status = vfs_stat_fsp(fsp);
1273                 if (!NT_STATUS_IS_OK(status)) {
1274                         return status;
1275                 }
1276
1277                 *out_len = 16;
1278                 out_data_tmp = talloc_array(ctx, char, *out_len);
1279                 if (out_data_tmp == NULL) {
1280                         DEBUG(10, ("unable to allocate memory for response\n"));
1281                         return NT_STATUS_NO_MEMORY;
1282                 }
1283
1284                 if (offset > fsp->fsp_name->st.st_ex_size ||
1285                                 fsp->fsp_name->st.st_ex_size == 0 ||
1286                                 length == 0) {
1287                         memset(out_data_tmp, 0, *out_len);
1288                 } else {
1289                         uint64_t end = offset + length;
1290                         end = MIN(end, fsp->fsp_name->st.st_ex_size);
1291                         SBVAL(out_data_tmp, 0, 0);
1292                         SBVAL(out_data_tmp, 8, end);
1293                 }
1294
1295                 *out_data = out_data_tmp;
1296
1297                 return NT_STATUS_OK;
1298         }
1299
1300         case FSCTL_IS_VOLUME_DIRTY:
1301         {
1302                 DEBUG(10,("FSCTL_IS_VOLUME_DIRTY: called on %s "
1303                           "(but remotely not supported)\n", fsp_fnum_dbg(fsp)));
1304                 /*
1305                  * http://msdn.microsoft.com/en-us/library/cc232128%28PROT.10%29.aspx
1306                  * says we have to respond with NT_STATUS_INVALID_PARAMETER
1307                  */
1308                 return NT_STATUS_INVALID_PARAMETER;
1309         }
1310
1311         default:
1312                 /*
1313                  * Only print once ... unfortunately there could be lots of
1314                  * different FSCTLs that are called.
1315                  */
1316                 if (!vfswrap_logged_ioctl_message) {
1317                         vfswrap_logged_ioctl_message = true;
1318                         DEBUG(2, ("%s (0x%x): Currently not implemented.\n",
1319                         __func__, function));
1320                 }
1321         }
1322
1323         return NT_STATUS_NOT_SUPPORTED;
1324 }
1325
1326 /********************************************************************
1327  Given a stat buffer return the allocated size on disk, taking into
1328  account sparse files.
1329 ********************************************************************/
1330 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct *handle,
1331                                        struct files_struct *fsp,
1332                                        const SMB_STRUCT_STAT *sbuf)
1333 {
1334         uint64_t result;
1335
1336         START_PROFILE(syscall_get_alloc_size);
1337
1338         if(S_ISDIR(sbuf->st_ex_mode)) {
1339                 result = 0;
1340                 goto out;
1341         }
1342
1343 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
1344         /* The type of st_blocksize is blkcnt_t which *MUST* be
1345            signed (according to POSIX) and can be less than 64-bits.
1346            Ensure when we're converting to 64 bits wide we don't
1347            sign extend. */
1348 #if defined(SIZEOF_BLKCNT_T_8)
1349         result = (uint64_t)STAT_ST_BLOCKSIZE * (uint64_t)sbuf->st_ex_blocks;
1350 #elif defined(SIZEOF_BLKCNT_T_4)
1351         {
1352                 uint64_t bs = ((uint64_t)sbuf->st_ex_blocks) & 0xFFFFFFFFLL;
1353                 result = (uint64_t)STAT_ST_BLOCKSIZE * bs;
1354         }
1355 #else
1356 #error SIZEOF_BLKCNT_T_NOT_A_SUPPORTED_VALUE
1357 #endif
1358         if (result == 0) {
1359                 /*
1360                  * Some file systems do not allocate a block for very
1361                  * small files. But for non-empty file should report a
1362                  * positive size.
1363                  */
1364
1365                 uint64_t filesize = get_file_size_stat(sbuf);
1366                 if (filesize > 0) {
1367                         result = MIN((uint64_t)STAT_ST_BLOCKSIZE, filesize);
1368                 }
1369         }
1370 #else
1371         result = get_file_size_stat(sbuf);
1372 #endif
1373
1374         if (fsp && fsp->initial_allocation_size)
1375                 result = MAX(result,fsp->initial_allocation_size);
1376
1377         result = smb_roundup(handle->conn, result);
1378
1379  out:
1380         END_PROFILE(syscall_get_alloc_size);
1381         return result;
1382 }
1383
1384 static int vfswrap_unlink(vfs_handle_struct *handle,
1385                           const struct smb_filename *smb_fname)
1386 {
1387         int result = -1;
1388
1389         START_PROFILE(syscall_unlink);
1390
1391         if (smb_fname->stream_name) {
1392                 errno = ENOENT;
1393                 goto out;
1394         }
1395         result = unlink(smb_fname->base_name);
1396
1397  out:
1398         END_PROFILE(syscall_unlink);
1399         return result;
1400 }
1401
1402 static int vfswrap_chmod(vfs_handle_struct *handle,  const char *path, mode_t mode)
1403 {
1404         int result;
1405
1406         START_PROFILE(syscall_chmod);
1407
1408         /*
1409          * We need to do this due to the fact that the default POSIX ACL
1410          * chmod modifies the ACL *mask* for the group owner, not the
1411          * group owner bits directly. JRA.
1412          */
1413
1414
1415         {
1416                 int saved_errno = errno; /* We might get ENOSYS */
1417                 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
1418                         END_PROFILE(syscall_chmod);
1419                         return result;
1420                 }
1421                 /* Error - return the old errno. */
1422                 errno = saved_errno;
1423         }
1424
1425         result = chmod(path, mode);
1426         END_PROFILE(syscall_chmod);
1427         return result;
1428 }
1429
1430 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1431 {
1432         int result;
1433
1434         START_PROFILE(syscall_fchmod);
1435
1436         /*
1437          * We need to do this due to the fact that the default POSIX ACL
1438          * chmod modifies the ACL *mask* for the group owner, not the
1439          * group owner bits directly. JRA.
1440          */
1441
1442         {
1443                 int saved_errno = errno; /* We might get ENOSYS */
1444                 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
1445                         END_PROFILE(syscall_fchmod);
1446                         return result;
1447                 }
1448                 /* Error - return the old errno. */
1449                 errno = saved_errno;
1450         }
1451
1452 #if defined(HAVE_FCHMOD)
1453         result = fchmod(fsp->fh->fd, mode);
1454 #else
1455         result = -1;
1456         errno = ENOSYS;
1457 #endif
1458
1459         END_PROFILE(syscall_fchmod);
1460         return result;
1461 }
1462
1463 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
1464 {
1465         int result;
1466
1467         START_PROFILE(syscall_chown);
1468         result = chown(path, uid, gid);
1469         END_PROFILE(syscall_chown);
1470         return result;
1471 }
1472
1473 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
1474 {
1475 #ifdef HAVE_FCHOWN
1476         int result;
1477
1478         START_PROFILE(syscall_fchown);
1479         result = fchown(fsp->fh->fd, uid, gid);
1480         END_PROFILE(syscall_fchown);
1481         return result;
1482 #else
1483         errno = ENOSYS;
1484         return -1;
1485 #endif
1486 }
1487
1488 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
1489 {
1490         int result;
1491
1492         START_PROFILE(syscall_lchown);
1493         result = lchown(path, uid, gid);
1494         END_PROFILE(syscall_lchown);
1495         return result;
1496 }
1497
1498 static int vfswrap_chdir(vfs_handle_struct *handle,  const char *path)
1499 {
1500         int result;
1501
1502         START_PROFILE(syscall_chdir);
1503         result = chdir(path);
1504         END_PROFILE(syscall_chdir);
1505         return result;
1506 }
1507
1508 static char *vfswrap_getwd(vfs_handle_struct *handle)
1509 {
1510         char *result;
1511
1512         START_PROFILE(syscall_getwd);
1513         result = sys_getwd();
1514         END_PROFILE(syscall_getwd);
1515         return result;
1516 }
1517
1518 /*********************************************************************
1519  nsec timestamp resolution call. Convert down to whatever the underlying
1520  system will support.
1521 **********************************************************************/
1522
1523 static int vfswrap_ntimes(vfs_handle_struct *handle,
1524                           const struct smb_filename *smb_fname,
1525                           struct smb_file_time *ft)
1526 {
1527         int result = -1;
1528
1529         START_PROFILE(syscall_ntimes);
1530
1531         if (smb_fname->stream_name) {
1532                 errno = ENOENT;
1533                 goto out;
1534         }
1535
1536         if (ft != NULL) {
1537                 if (null_timespec(ft->atime)) {
1538                         ft->atime= smb_fname->st.st_ex_atime;
1539                 }
1540
1541                 if (null_timespec(ft->mtime)) {
1542                         ft->mtime = smb_fname->st.st_ex_mtime;
1543                 }
1544
1545                 if (!null_timespec(ft->create_time)) {
1546                         set_create_timespec_ea(handle->conn,
1547                                                smb_fname,
1548                                                ft->create_time);
1549                 }
1550
1551                 if ((timespec_compare(&ft->atime,
1552                                       &smb_fname->st.st_ex_atime) == 0) &&
1553                     (timespec_compare(&ft->mtime,
1554                                       &smb_fname->st.st_ex_mtime) == 0)) {
1555                         return 0;
1556                 }
1557         }
1558
1559 #if defined(HAVE_UTIMENSAT)
1560         if (ft != NULL) {
1561                 struct timespec ts[2];
1562                 ts[0] = ft->atime;
1563                 ts[1] = ft->mtime;
1564                 result = utimensat(AT_FDCWD, smb_fname->base_name, ts, 0);
1565         } else {
1566                 result = utimensat(AT_FDCWD, smb_fname->base_name, NULL, 0);
1567         }
1568         if (!((result == -1) && (errno == ENOSYS))) {
1569                 goto out;
1570         }
1571 #endif
1572 #if defined(HAVE_UTIMES)
1573         if (ft != NULL) {
1574                 struct timeval tv[2];
1575                 tv[0] = convert_timespec_to_timeval(ft->atime);
1576                 tv[1] = convert_timespec_to_timeval(ft->mtime);
1577                 result = utimes(smb_fname->base_name, tv);
1578         } else {
1579                 result = utimes(smb_fname->base_name, NULL);
1580         }
1581         if (!((result == -1) && (errno == ENOSYS))) {
1582                 goto out;
1583         }
1584 #endif
1585 #if defined(HAVE_UTIME)
1586         if (ft != NULL) {
1587                 struct utimbuf times;
1588                 times.actime = convert_timespec_to_time_t(ft->atime);
1589                 times.modtime = convert_timespec_to_time_t(ft->mtime);
1590                 result = utime(smb_fname->base_name, &times);
1591         } else {
1592                 result = utime(smb_fname->base_name, NULL);
1593         }
1594         if (!((result == -1) && (errno == ENOSYS))) {
1595                 goto out;
1596         }
1597 #endif
1598         errno = ENOSYS;
1599         result = -1;
1600
1601  out:
1602         END_PROFILE(syscall_ntimes);
1603         return result;
1604 }
1605
1606 /*********************************************************************
1607  A version of ftruncate that will write the space on disk if strict
1608  allocate is set.
1609 **********************************************************************/
1610
1611 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
1612 {
1613         off_t space_to_write;
1614         uint64_t space_avail;
1615         uint64_t bsize,dfree,dsize;
1616         int ret;
1617         NTSTATUS status;
1618         SMB_STRUCT_STAT *pst;
1619
1620         status = vfs_stat_fsp(fsp);
1621         if (!NT_STATUS_IS_OK(status)) {
1622                 return -1;
1623         }
1624         pst = &fsp->fsp_name->st;
1625
1626 #ifdef S_ISFIFO
1627         if (S_ISFIFO(pst->st_ex_mode))
1628                 return 0;
1629 #endif
1630
1631         if (pst->st_ex_size == len)
1632                 return 0;
1633
1634         /* Shrink - just ftruncate. */
1635         if (pst->st_ex_size > len)
1636                 return ftruncate(fsp->fh->fd, len);
1637
1638         space_to_write = len - pst->st_ex_size;
1639
1640         /* for allocation try fallocate first. This can fail on some
1641            platforms e.g. when the filesystem doesn't support it and no
1642            emulation is being done by the libc (like on AIX with JFS1). In that
1643            case we do our own emulation. fallocate implementations can
1644            return ENOTSUP or EINVAL in cases like that. */
1645         ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
1646                                 pst->st_ex_size, space_to_write);
1647         if (ret == -1 && errno == ENOSPC) {
1648                 return -1;
1649         }
1650         if (ret == 0) {
1651                 return 0;
1652         }
1653         DEBUG(10,("strict_allocate_ftruncate: SMB_VFS_FALLOCATE failed with "
1654                 "error %d. Falling back to slow manual allocation\n", errno));
1655
1656         /* available disk space is enough or not? */
1657         space_avail = get_dfree_info(fsp->conn,
1658                                      fsp->fsp_name->base_name, false,
1659                                      &bsize,&dfree,&dsize);
1660         /* space_avail is 1k blocks */
1661         if (space_avail == (uint64_t)-1 ||
1662                         ((uint64_t)space_to_write/1024 > space_avail) ) {
1663                 errno = ENOSPC;
1664                 return -1;
1665         }
1666
1667         /* Write out the real space on disk. */
1668         ret = vfs_slow_fallocate(fsp, pst->st_ex_size, space_to_write);
1669         if (ret != 0) {
1670                 return -1;
1671         }
1672
1673         return 0;
1674 }
1675
1676 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, off_t len)
1677 {
1678         int result = -1;
1679         SMB_STRUCT_STAT *pst;
1680         NTSTATUS status;
1681         char c = 0;
1682
1683         START_PROFILE(syscall_ftruncate);
1684
1685         if (lp_strict_allocate(SNUM(fsp->conn)) && !fsp->is_sparse) {
1686                 result = strict_allocate_ftruncate(handle, fsp, len);
1687                 END_PROFILE(syscall_ftruncate);
1688                 return result;
1689         }
1690
1691         /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
1692            ftruncate if the system supports it. Then I discovered that
1693            you can have some filesystems that support ftruncate
1694            expansion and some that don't! On Linux fat can't do
1695            ftruncate extend but ext2 can. */
1696
1697         result = ftruncate(fsp->fh->fd, len);
1698         if (result == 0)
1699                 goto done;
1700
1701         /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
1702            extend a file with ftruncate. Provide alternate implementation
1703            for this */
1704
1705         /* Do an fstat to see if the file is longer than the requested
1706            size in which case the ftruncate above should have
1707            succeeded or shorter, in which case seek to len - 1 and
1708            write 1 byte of zero */
1709         status = vfs_stat_fsp(fsp);
1710         if (!NT_STATUS_IS_OK(status)) {
1711                 goto done;
1712         }
1713         pst = &fsp->fsp_name->st;
1714
1715 #ifdef S_ISFIFO
1716         if (S_ISFIFO(pst->st_ex_mode)) {
1717                 result = 0;
1718                 goto done;
1719         }
1720 #endif
1721
1722         if (pst->st_ex_size == len) {
1723                 result = 0;
1724                 goto done;
1725         }
1726
1727         if (pst->st_ex_size > len) {
1728                 /* the ftruncate should have worked */
1729                 goto done;
1730         }
1731
1732         if (SMB_VFS_PWRITE(fsp, &c, 1, len-1)!=1) {
1733                 goto done;
1734         }
1735
1736         result = 0;
1737
1738   done:
1739
1740         END_PROFILE(syscall_ftruncate);
1741         return result;
1742 }
1743
1744 static int vfswrap_fallocate(vfs_handle_struct *handle,
1745                         files_struct *fsp,
1746                         enum vfs_fallocate_mode mode,
1747                         off_t offset,
1748                         off_t len)
1749 {
1750         int result;
1751
1752         START_PROFILE(syscall_fallocate);
1753         if (mode == VFS_FALLOCATE_EXTEND_SIZE) {
1754                 result = sys_posix_fallocate(fsp->fh->fd, offset, len);
1755                 /*
1756                  * posix_fallocate returns 0 on success, errno on error
1757                  * and doesn't set errno. Make it behave like fallocate()
1758                  * which returns -1, and sets errno on failure.
1759                  */
1760                 if (result != 0) {
1761                         errno = result;
1762                         result = -1;
1763                 }
1764         } else if (mode == VFS_FALLOCATE_KEEP_SIZE) {
1765                 result = sys_fallocate(fsp->fh->fd, mode, offset, len);
1766         } else {
1767                 errno = EINVAL;
1768                 result = -1;
1769         }
1770         END_PROFILE(syscall_fallocate);
1771         return result;
1772 }
1773
1774 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, off_t offset, off_t count, int type)
1775 {
1776         bool result;
1777
1778         START_PROFILE(syscall_fcntl_lock);
1779         result =  fcntl_lock(fsp->fh->fd, op, offset, count, type);
1780         END_PROFILE(syscall_fcntl_lock);
1781         return result;
1782 }
1783
1784 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
1785                                 uint32 share_mode, uint32 access_mask)
1786 {
1787         START_PROFILE(syscall_kernel_flock);
1788         kernel_flock(fsp->fh->fd, share_mode, access_mask);
1789         END_PROFILE(syscall_kernel_flock);
1790         return 0;
1791 }
1792
1793 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, off_t *poffset, off_t *pcount, int *ptype, pid_t *ppid)
1794 {
1795         bool result;
1796
1797         START_PROFILE(syscall_fcntl_getlock);
1798         result =  fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
1799         END_PROFILE(syscall_fcntl_getlock);
1800         return result;
1801 }
1802
1803 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
1804                                 int leasetype)
1805 {
1806         int result = -1;
1807
1808         START_PROFILE(syscall_linux_setlease);
1809
1810 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
1811         result = linux_setlease(fsp->fh->fd, leasetype);
1812 #else
1813         errno = ENOSYS;
1814 #endif
1815         END_PROFILE(syscall_linux_setlease);
1816         return result;
1817 }
1818
1819 static int vfswrap_symlink(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1820 {
1821         int result;
1822
1823         START_PROFILE(syscall_symlink);
1824         result = symlink(oldpath, newpath);
1825         END_PROFILE(syscall_symlink);
1826         return result;
1827 }
1828
1829 static int vfswrap_readlink(vfs_handle_struct *handle,  const char *path, char *buf, size_t bufsiz)
1830 {
1831         int result;
1832
1833         START_PROFILE(syscall_readlink);
1834         result = readlink(path, buf, bufsiz);
1835         END_PROFILE(syscall_readlink);
1836         return result;
1837 }
1838
1839 static int vfswrap_link(vfs_handle_struct *handle,  const char *oldpath, const char *newpath)
1840 {
1841         int result;
1842
1843         START_PROFILE(syscall_link);
1844         result = link(oldpath, newpath);
1845         END_PROFILE(syscall_link);
1846         return result;
1847 }
1848
1849 static int vfswrap_mknod(vfs_handle_struct *handle,  const char *pathname, mode_t mode, SMB_DEV_T dev)
1850 {
1851         int result;
1852
1853         START_PROFILE(syscall_mknod);
1854         result = sys_mknod(pathname, mode, dev);
1855         END_PROFILE(syscall_mknod);
1856         return result;
1857 }
1858
1859 static char *vfswrap_realpath(vfs_handle_struct *handle,  const char *path)
1860 {
1861         char *result;
1862
1863         START_PROFILE(syscall_realpath);
1864 #ifdef REALPATH_TAKES_NULL
1865         result = realpath(path, NULL);
1866 #else
1867         result = SMB_MALLOC_ARRAY(char, PATH_MAX+1);
1868         if (result) {
1869                 char *resolved_path = realpath(path, result);
1870                 if (!resolved_path) {
1871                         SAFE_FREE(result);
1872                 } else {
1873                         /* SMB_ASSERT(result == resolved_path) ? */
1874                         result = resolved_path;
1875                 }
1876         }
1877 #endif
1878         END_PROFILE(syscall_realpath);
1879         return result;
1880 }
1881
1882 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
1883                                      struct sys_notify_context *ctx,
1884                                      const char *path,
1885                                      uint32_t *filter,
1886                                      uint32_t *subdir_filter,
1887                                      void (*callback)(struct sys_notify_context *ctx,
1888                                                       void *private_data,
1889                                                       struct notify_event *ev),
1890                                      void *private_data, void *handle)
1891 {
1892         /*
1893          * So far inotify is the only supported default notify mechanism. If
1894          * another platform like the the BSD's or a proprietary Unix comes
1895          * along and wants another default, we can play the same trick we
1896          * played with Posix ACLs.
1897          *
1898          * Until that is the case, hard-code inotify here.
1899          */
1900 #ifdef HAVE_INOTIFY
1901         if (lp_kernel_change_notify(vfs_handle->conn->params)) {
1902                 return inotify_watch(ctx, path, filter, subdir_filter,
1903                                      callback, private_data, handle);
1904         }
1905 #endif
1906         /*
1907          * Do nothing, leave everything to notify_internal.c
1908          */
1909         return NT_STATUS_OK;
1910 }
1911
1912 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path,
1913                            unsigned int flags)
1914 {
1915 #ifdef HAVE_CHFLAGS
1916         return chflags(path, flags);
1917 #else
1918         errno = ENOSYS;
1919         return -1;
1920 #endif
1921 }
1922
1923 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle,
1924                                              const SMB_STRUCT_STAT *sbuf)
1925 {
1926         struct file_id key;
1927
1928         /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1929          * blob */
1930         ZERO_STRUCT(key);
1931
1932         key.devid = sbuf->st_ex_dev;
1933         key.inode = sbuf->st_ex_ino;
1934         /* key.extid is unused by default. */
1935
1936         return key;
1937 }
1938
1939 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1940                                    struct files_struct *fsp,
1941                                    const char *fname,
1942                                    TALLOC_CTX *mem_ctx,
1943                                    unsigned int *pnum_streams,
1944                                    struct stream_struct **pstreams)
1945 {
1946         SMB_STRUCT_STAT sbuf;
1947         struct stream_struct *tmp_streams = NULL;
1948         int ret;
1949
1950         if ((fsp != NULL) && (fsp->is_directory)) {
1951                 /*
1952                  * No default streams on directories
1953                  */
1954                 goto done;
1955         }
1956
1957         if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1958                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1959         }
1960         else {
1961                 struct smb_filename smb_fname;
1962
1963                 ZERO_STRUCT(smb_fname);
1964                 smb_fname.base_name = discard_const_p(char, fname);
1965
1966                 if (lp_posix_pathnames()) {
1967                         ret = SMB_VFS_LSTAT(handle->conn, &smb_fname);
1968                 } else {
1969                         ret = SMB_VFS_STAT(handle->conn, &smb_fname);
1970                 }
1971                 sbuf = smb_fname.st;
1972         }
1973
1974         if (ret == -1) {
1975                 return map_nt_error_from_unix(errno);
1976         }
1977
1978         if (S_ISDIR(sbuf.st_ex_mode)) {
1979                 goto done;
1980         }
1981
1982         tmp_streams = talloc_realloc(mem_ctx, *pstreams, struct stream_struct,
1983                                         (*pnum_streams) + 1);
1984         if (tmp_streams == NULL) {
1985                 return NT_STATUS_NO_MEMORY;
1986         }
1987         tmp_streams[*pnum_streams].name = talloc_strdup(tmp_streams, "::$DATA");
1988         if (tmp_streams[*pnum_streams].name == NULL) {
1989                 return NT_STATUS_NO_MEMORY;
1990         }
1991         tmp_streams[*pnum_streams].size = sbuf.st_ex_size;
1992         tmp_streams[*pnum_streams].alloc_size = SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp, &sbuf);
1993
1994         *pnum_streams += 1;
1995         *pstreams = tmp_streams;
1996  done:
1997         return NT_STATUS_OK;
1998 }
1999
2000 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
2001                                      const char *path,
2002                                      const char *name,
2003                                      TALLOC_CTX *mem_ctx,
2004                                      char **found_name)
2005 {
2006         /*
2007          * Don't fall back to get_real_filename so callers can differentiate
2008          * between a full directory scan and an actual case-insensitive stat.
2009          */
2010         errno = EOPNOTSUPP;
2011         return -1;
2012 }
2013
2014 static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
2015                                        const char *fname)
2016 {
2017         return handle->conn->connectpath;
2018 }
2019
2020 static NTSTATUS vfswrap_brl_lock_windows(struct vfs_handle_struct *handle,
2021                                          struct byte_range_lock *br_lck,
2022                                          struct lock_struct *plock,
2023                                          bool blocking_lock,
2024                                          struct blocking_lock_record *blr)
2025 {
2026         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2027
2028         /* Note: blr is not used in the default implementation. */
2029         return brl_lock_windows_default(br_lck, plock, blocking_lock);
2030 }
2031
2032 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct *handle,
2033                                        struct messaging_context *msg_ctx,
2034                                        struct byte_range_lock *br_lck,
2035                                        const struct lock_struct *plock)
2036 {
2037         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2038
2039         return brl_unlock_windows_default(msg_ctx, br_lck, plock);
2040 }
2041
2042 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct *handle,
2043                                        struct byte_range_lock *br_lck,
2044                                        struct lock_struct *plock,
2045                                        struct blocking_lock_record *blr)
2046 {
2047         SMB_ASSERT(plock->lock_flav == WINDOWS_LOCK);
2048
2049         /* Note: blr is not used in the default implementation. */
2050         return brl_lock_cancel_default(br_lck, plock);
2051 }
2052
2053 static bool vfswrap_strict_lock(struct vfs_handle_struct *handle,
2054                                 files_struct *fsp,
2055                                 struct lock_struct *plock)
2056 {
2057         SMB_ASSERT(plock->lock_type == READ_LOCK ||
2058             plock->lock_type == WRITE_LOCK);
2059
2060         return strict_lock_default(fsp, plock);
2061 }
2062
2063 static void vfswrap_strict_unlock(struct vfs_handle_struct *handle,
2064                                 files_struct *fsp,
2065                                 struct lock_struct *plock)
2066 {
2067         SMB_ASSERT(plock->lock_type == READ_LOCK ||
2068             plock->lock_type == WRITE_LOCK);
2069
2070         strict_unlock_default(fsp, plock);
2071 }
2072
2073 /* NT ACL operations. */
2074
2075 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
2076                                     files_struct *fsp,
2077                                     uint32 security_info,
2078                                     TALLOC_CTX *mem_ctx,
2079                                     struct security_descriptor **ppdesc)
2080 {
2081         NTSTATUS result;
2082
2083         START_PROFILE(fget_nt_acl);
2084         result = posix_fget_nt_acl(fsp, security_info,
2085                                    mem_ctx, ppdesc);
2086         END_PROFILE(fget_nt_acl);
2087         return result;
2088 }
2089
2090 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
2091                                    const char *name,
2092                                    uint32 security_info,
2093                                    TALLOC_CTX *mem_ctx,
2094                                    struct security_descriptor **ppdesc)
2095 {
2096         NTSTATUS result;
2097
2098         START_PROFILE(get_nt_acl);
2099         result = posix_get_nt_acl(handle->conn, name, security_info,
2100                                   mem_ctx, ppdesc);
2101         END_PROFILE(get_nt_acl);
2102         return result;
2103 }
2104
2105 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const struct security_descriptor *psd)
2106 {
2107         NTSTATUS result;
2108
2109         START_PROFILE(fset_nt_acl);
2110         result = set_nt_acl(fsp, security_info_sent, psd);
2111         END_PROFILE(fset_nt_acl);
2112         return result;
2113 }
2114
2115 static NTSTATUS vfswrap_audit_file(struct vfs_handle_struct *handle,
2116                                    struct smb_filename *file,
2117                                    struct security_acl *sacl,
2118                                    uint32_t access_requested,
2119                                    uint32_t access_denied)
2120 {
2121         return NT_STATUS_OK; /* Nothing to do here ... */
2122 }
2123
2124 static int vfswrap_chmod_acl(vfs_handle_struct *handle,  const char *name, mode_t mode)
2125 {
2126 #ifdef HAVE_NO_ACL
2127         errno = ENOSYS;
2128         return -1;
2129 #else
2130         int result;
2131
2132         START_PROFILE(chmod_acl);
2133         result = chmod_acl(handle->conn, name, mode);
2134         END_PROFILE(chmod_acl);
2135         return result;
2136 #endif
2137 }
2138
2139 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
2140 {
2141 #ifdef HAVE_NO_ACL
2142         errno = ENOSYS;
2143         return -1;
2144 #else
2145         int result;
2146
2147         START_PROFILE(fchmod_acl);
2148         result = fchmod_acl(fsp, mode);
2149         END_PROFILE(fchmod_acl);
2150         return result;
2151 #endif
2152 }
2153
2154 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,
2155                                           const char *path_p,
2156                                           SMB_ACL_TYPE_T type,
2157                                           TALLOC_CTX *mem_ctx)
2158 {
2159         return sys_acl_get_file(handle, path_p, type, mem_ctx);
2160 }
2161
2162 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle,
2163                                         files_struct *fsp,
2164                                         TALLOC_CTX *mem_ctx)
2165 {
2166         return sys_acl_get_fd(handle, fsp, mem_ctx);
2167 }
2168
2169 static int vfswrap_sys_acl_blob_get_file(vfs_handle_struct *handle,
2170                                          const char *path_p,
2171                                          TALLOC_CTX *mem_ctx,
2172                                          char **blob_description,
2173                                          DATA_BLOB *blob)
2174 {
2175         errno = ENOSYS;
2176         return -1;
2177 }
2178
2179 static int vfswrap_sys_acl_blob_get_fd(vfs_handle_struct *handle,
2180                                        files_struct *fsp,
2181                                        TALLOC_CTX *mem_ctx,
2182                                        char **blob_description,
2183                                        DATA_BLOB *blob)
2184 {
2185         errno = ENOSYS;
2186         return -1;
2187 }
2188
2189 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle,  const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
2190 {
2191         return sys_acl_set_file(handle, name, acltype, theacl);
2192 }
2193
2194 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
2195 {
2196         return sys_acl_set_fd(handle, fsp, theacl);
2197 }
2198
2199 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle,  const char *path)
2200 {
2201         return sys_acl_delete_def_file(handle, path);
2202 }
2203
2204 /****************************************************************
2205  Extended attribute operations.
2206 *****************************************************************/
2207
2208 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
2209 {
2210         return getxattr(path, name, value, size);
2211 }
2212
2213 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
2214 {
2215         return fgetxattr(fsp->fh->fd, name, value, size);
2216 }
2217
2218 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
2219 {
2220         return listxattr(path, list, size);
2221 }
2222
2223 static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
2224 {
2225         return flistxattr(fsp->fh->fd, list, size);
2226 }
2227
2228 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
2229 {
2230         return removexattr(path, name);
2231 }
2232
2233 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
2234 {
2235         return fremovexattr(fsp->fh->fd, name);
2236 }
2237
2238 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
2239 {
2240         return setxattr(path, name, value, size, flags);
2241 }
2242
2243 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
2244 {
2245         return fsetxattr(fsp->fh->fd, name, value, size, flags);
2246 }
2247
2248 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
2249 {
2250         return false;
2251 }
2252
2253 static bool vfswrap_is_offline(struct vfs_handle_struct *handle,
2254                                const struct smb_filename *fname,
2255                                SMB_STRUCT_STAT *sbuf)
2256 {
2257         NTSTATUS status;
2258         char *path;
2259         bool offline = false;
2260
2261         if (ISDOT(fname->base_name) || ISDOTDOT(fname->base_name)) {
2262                 return false;
2263         }
2264
2265         if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
2266 #if defined(ENOTSUP)
2267                 errno = ENOTSUP;
2268 #endif
2269                 return false;
2270         }
2271
2272         status = get_full_smb_filename(talloc_tos(), fname, &path);
2273         if (!NT_STATUS_IS_OK(status)) {
2274                 errno = map_errno_from_nt_status(status);
2275                 return false;
2276         }
2277
2278         offline = (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
2279
2280         TALLOC_FREE(path);
2281
2282         return offline;
2283 }
2284
2285 static int vfswrap_set_offline(struct vfs_handle_struct *handle,
2286                                const struct smb_filename *fname)
2287 {
2288         /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
2289 #if defined(ENOTSUP)
2290         errno = ENOTSUP;
2291 #endif
2292         return -1;
2293 }
2294
2295 static NTSTATUS vfswrap_durable_cookie(struct vfs_handle_struct *handle,
2296                                        struct files_struct *fsp,
2297                                        TALLOC_CTX *mem_ctx,
2298                                        DATA_BLOB *cookie)
2299 {
2300         return vfs_default_durable_cookie(fsp, mem_ctx, cookie);
2301 }
2302
2303 static NTSTATUS vfswrap_durable_disconnect(struct vfs_handle_struct *handle,
2304                                            struct files_struct *fsp,
2305                                            const DATA_BLOB old_cookie,
2306                                            TALLOC_CTX *mem_ctx,
2307                                            DATA_BLOB *new_cookie)
2308 {
2309         return vfs_default_durable_disconnect(fsp, old_cookie, mem_ctx,
2310                                               new_cookie);
2311 }
2312
2313 static NTSTATUS vfswrap_durable_reconnect(struct vfs_handle_struct *handle,
2314                                           struct smb_request *smb1req,
2315                                           struct smbXsrv_open *op,
2316                                           const DATA_BLOB old_cookie,
2317                                           TALLOC_CTX *mem_ctx,
2318                                           struct files_struct **fsp,
2319                                           DATA_BLOB *new_cookie)
2320 {
2321         return vfs_default_durable_reconnect(handle->conn, smb1req, op,
2322                                              old_cookie, mem_ctx,
2323                                              fsp, new_cookie);
2324 }
2325
2326 static struct vfs_fn_pointers vfs_default_fns = {
2327         /* Disk operations */
2328
2329         .connect_fn = vfswrap_connect,
2330         .disconnect_fn = vfswrap_disconnect,
2331         .disk_free_fn = vfswrap_disk_free,
2332         .get_quota_fn = vfswrap_get_quota,
2333         .set_quota_fn = vfswrap_set_quota,
2334         .get_shadow_copy_data_fn = vfswrap_get_shadow_copy_data,
2335         .statvfs_fn = vfswrap_statvfs,
2336         .fs_capabilities_fn = vfswrap_fs_capabilities,
2337         .get_dfs_referrals_fn = vfswrap_get_dfs_referrals,
2338
2339         /* Directory operations */
2340
2341         .opendir_fn = vfswrap_opendir,
2342         .fdopendir_fn = vfswrap_fdopendir,
2343         .readdir_fn = vfswrap_readdir,
2344         .seekdir_fn = vfswrap_seekdir,
2345         .telldir_fn = vfswrap_telldir,
2346         .rewind_dir_fn = vfswrap_rewinddir,
2347         .mkdir_fn = vfswrap_mkdir,
2348         .rmdir_fn = vfswrap_rmdir,
2349         .closedir_fn = vfswrap_closedir,
2350         .init_search_op_fn = vfswrap_init_search_op,
2351
2352         /* File operations */
2353
2354         .open_fn = vfswrap_open,
2355         .create_file_fn = vfswrap_create_file,
2356         .close_fn = vfswrap_close,
2357         .read_fn = vfswrap_read,
2358         .pread_fn = vfswrap_pread,
2359         .pread_send_fn = vfswrap_pread_send,
2360         .pread_recv_fn = vfswrap_asys_ssize_t_recv,
2361         .write_fn = vfswrap_write,
2362         .pwrite_fn = vfswrap_pwrite,
2363         .pwrite_send_fn = vfswrap_pwrite_send,
2364         .pwrite_recv_fn = vfswrap_asys_ssize_t_recv,
2365         .lseek_fn = vfswrap_lseek,
2366         .sendfile_fn = vfswrap_sendfile,
2367         .recvfile_fn = vfswrap_recvfile,
2368         .rename_fn = vfswrap_rename,
2369         .fsync_fn = vfswrap_fsync,
2370         .fsync_send_fn = vfswrap_fsync_send,
2371         .fsync_recv_fn = vfswrap_asys_int_recv,
2372         .stat_fn = vfswrap_stat,
2373         .fstat_fn = vfswrap_fstat,
2374         .lstat_fn = vfswrap_lstat,
2375         .get_alloc_size_fn = vfswrap_get_alloc_size,
2376         .unlink_fn = vfswrap_unlink,
2377         .chmod_fn = vfswrap_chmod,
2378         .fchmod_fn = vfswrap_fchmod,
2379         .chown_fn = vfswrap_chown,
2380         .fchown_fn = vfswrap_fchown,
2381         .lchown_fn = vfswrap_lchown,
2382         .chdir_fn = vfswrap_chdir,
2383         .getwd_fn = vfswrap_getwd,
2384         .ntimes_fn = vfswrap_ntimes,
2385         .ftruncate_fn = vfswrap_ftruncate,
2386         .fallocate_fn = vfswrap_fallocate,
2387         .lock_fn = vfswrap_lock,
2388         .kernel_flock_fn = vfswrap_kernel_flock,
2389         .linux_setlease_fn = vfswrap_linux_setlease,
2390         .getlock_fn = vfswrap_getlock,
2391         .symlink_fn = vfswrap_symlink,
2392         .readlink_fn = vfswrap_readlink,
2393         .link_fn = vfswrap_link,
2394         .mknod_fn = vfswrap_mknod,
2395         .realpath_fn = vfswrap_realpath,
2396         .notify_watch_fn = vfswrap_notify_watch,
2397         .chflags_fn = vfswrap_chflags,
2398         .file_id_create_fn = vfswrap_file_id_create,
2399         .streaminfo_fn = vfswrap_streaminfo,
2400         .get_real_filename_fn = vfswrap_get_real_filename,
2401         .connectpath_fn = vfswrap_connectpath,
2402         .brl_lock_windows_fn = vfswrap_brl_lock_windows,
2403         .brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
2404         .brl_cancel_windows_fn = vfswrap_brl_cancel_windows,
2405         .strict_lock_fn = vfswrap_strict_lock,
2406         .strict_unlock_fn = vfswrap_strict_unlock,
2407         .translate_name_fn = vfswrap_translate_name,
2408         .fsctl_fn = vfswrap_fsctl,
2409
2410         /* NT ACL operations. */
2411
2412         .fget_nt_acl_fn = vfswrap_fget_nt_acl,
2413         .get_nt_acl_fn = vfswrap_get_nt_acl,
2414         .fset_nt_acl_fn = vfswrap_fset_nt_acl,
2415         .audit_file_fn = vfswrap_audit_file,
2416
2417         /* POSIX ACL operations. */
2418
2419         .chmod_acl_fn = vfswrap_chmod_acl,
2420         .fchmod_acl_fn = vfswrap_fchmod_acl,
2421
2422         .sys_acl_get_file_fn = vfswrap_sys_acl_get_file,
2423         .sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd,
2424         .sys_acl_blob_get_file_fn = vfswrap_sys_acl_blob_get_file,
2425         .sys_acl_blob_get_fd_fn = vfswrap_sys_acl_blob_get_fd,
2426         .sys_acl_set_file_fn = vfswrap_sys_acl_set_file,
2427         .sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd,
2428         .sys_acl_delete_def_file_fn = vfswrap_sys_acl_delete_def_file,
2429
2430         /* EA operations. */
2431         .getxattr_fn = vfswrap_getxattr,
2432         .fgetxattr_fn = vfswrap_fgetxattr,
2433         .listxattr_fn = vfswrap_listxattr,
2434         .flistxattr_fn = vfswrap_flistxattr,
2435         .removexattr_fn = vfswrap_removexattr,
2436         .fremovexattr_fn = vfswrap_fremovexattr,
2437         .setxattr_fn = vfswrap_setxattr,
2438         .fsetxattr_fn = vfswrap_fsetxattr,
2439
2440         /* aio operations */
2441         .aio_force_fn = vfswrap_aio_force,
2442
2443         /* offline operations */
2444         .is_offline_fn = vfswrap_is_offline,
2445         .set_offline_fn = vfswrap_set_offline,
2446
2447         /* durable handle operations */
2448         .durable_cookie_fn = vfswrap_durable_cookie,
2449         .durable_disconnect_fn = vfswrap_durable_disconnect,
2450         .durable_reconnect_fn = vfswrap_durable_reconnect,
2451 };
2452
2453 NTSTATUS vfs_default_init(void);
2454 NTSTATUS vfs_default_init(void)
2455 {
2456         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2457                                 DEFAULT_VFS_MODULE_NAME, &vfs_default_fns);
2458 }
2459
2460