source3/smbd/vfs.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    VFS initialisation and support functions
   5    Copyright (C) Tim Potter 1999
   6    Copyright (C) Alexander Bokovoy 2002
   7    Copyright (C) James Peach 2006
   8    Copyright (C) Volker Lendecke 2009
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22
  23    This work was sponsored by Optifacio Software Services, Inc.
  24 */
  25
  26 #include "includes.h"
  27 #include "system/filesys.h"
  28 #include "smbd/smbd.h"
  29 #include "smbd/globals.h"
  30 #include "../lib/util/memcache.h"
  31 #include "transfer_file.h"
  32 #include "ntioctl.h"
  33 #include "lib/util/tevent_unix.h"
  34 #include "lib/util/tevent_ntstatus.h"
  35
  36 #undef DBGC_CLASS
  37 #define DBGC_CLASS DBGC_VFS
  38
  39 static_decl_vfs;
  40
  41 struct vfs_fsp_data {
  42     struct vfs_fsp_data *next;
  43     struct vfs_handle_struct *owner;
  44     void (*destroy)(void *p_data);
  45     void *_dummy_;
  46     /* NOTE: This structure contains four pointers so that we can guarantee
  47      * that the end of the structure is always both 4-byte and 8-byte aligned.
  48      */
  49 };
  50
  51 struct vfs_init_function_entry {
  52         char *name;
  53         struct vfs_init_function_entry *prev, *next;
  54         const struct vfs_fn_pointers *fns;
  55 };
  56
  57 /****************************************************************************
  58     maintain the list of available backends
  59 ****************************************************************************/
  60
  61 static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
  62 {
  63         struct vfs_init_function_entry *entry = backends;
  64
  65         DEBUG(10, ("vfs_find_backend_entry called for %s\n", name));
  66
  67         while(entry) {
  68                 if (strcmp(entry->name, name)==0) return entry;
  69                 entry = entry->next;
  70         }
  71
  72         return NULL;
  73 }
  74
  75 NTSTATUS smb_register_vfs(int version, const char *name,
  76                           const struct vfs_fn_pointers *fns)
  77 {
  78         struct vfs_init_function_entry *entry = backends;
  79
  80         if ((version != SMB_VFS_INTERFACE_VERSION)) {
  81                 DEBUG(0, ("Failed to register vfs module.\n"
  82                           "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
  83                           "current SMB_VFS_INTERFACE_VERSION is %d.\n"
  84                           "Please recompile against the current Samba Version!\n",
  85                           version, SMB_VFS_INTERFACE_VERSION));
  86                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
  87         }
  88
  89         if (!name || !name[0]) {
  90                 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
  91                 return NT_STATUS_INVALID_PARAMETER;
  92         }
  93
  94         if (vfs_find_backend_entry(name)) {
  95                 DEBUG(0,("VFS module %s already loaded!\n", name));
  96                 return NT_STATUS_OBJECT_NAME_COLLISION;
  97         }
  98
  99         entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
 100         entry->name = smb_xstrdup(name);
 101         entry->fns = fns;
 102
 103         DLIST_ADD(backends, entry);
 104         DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
 105         return NT_STATUS_OK;
 106 }
 107
 108 /****************************************************************************
 109   initialise default vfs hooks
 110 ****************************************************************************/
 111
 112 static void vfs_init_default(connection_struct *conn)
 113 {
 114         DEBUG(3, ("Initialising default vfs hooks\n"));
 115         vfs_init_custom(conn, DEFAULT_VFS_MODULE_NAME);
 116 }
 117
 118 /****************************************************************************
 119   initialise custom vfs hooks
 120  ****************************************************************************/
 121
 122 bool vfs_init_custom(connection_struct *conn, const char *vfs_object)
 123 {
 124         char *module_path = NULL;
 125         char *module_name = NULL;
 126         char *module_param = NULL, *p;
 127         vfs_handle_struct *handle;
 128         const struct vfs_init_function_entry *entry;
 129
 130         if (!conn||!vfs_object||!vfs_object[0]) {
 131                 DEBUG(0, ("vfs_init_custom() called with NULL pointer or "
 132                           "empty vfs_object!\n"));
 133                 return False;
 134         }
 135
 136         if(!backends) {
 137                 static_init_vfs(NULL);
 138         }
 139
 140         DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
 141
 142         module_path = smb_xstrdup(vfs_object);
 143
 144         p = strchr_m(module_path, ':');
 145
 146         if (p) {
 147                 *p = 0;
 148                 module_param = p+1;
 149                 trim_char(module_param, ' ', ' ');
 150         }
 151
 152         trim_char(module_path, ' ', ' ');
 153
 154         module_name = smb_xstrdup(module_path);
 155
 156         if ((module_name[0] == '/') &&
 157             (strcmp(module_path, DEFAULT_VFS_MODULE_NAME) != 0)) {
 158
 159                 /*
 160                  * Extract the module name from the path. Just use the base
 161                  * name of the last path component.
 162                  */
 163
 164                 SAFE_FREE(module_name);
 165                 module_name = smb_xstrdup(strrchr_m(module_path, '/')+1);
 166
 167                 p = strchr_m(module_name, '.');
 168
 169                 if (p != NULL) {
 170                         *p = '\0';
 171                 }
 172         }
 173
 174         /* First, try to load the module with the new module system */
 175         entry = vfs_find_backend_entry(module_name);
 176         if (!entry) {
 177                 NTSTATUS status;
 178
 179                 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
 180                           vfs_object));
 181
 182                 status = smb_load_module("vfs", module_path);
 183                 if (!NT_STATUS_IS_OK(status)) {
 184                         DEBUG(0, ("error probing vfs module '%s': %s\n",
 185                                   module_path, nt_errstr(status)));
 186                         goto fail;
 187                 }
 188
 189                 entry = vfs_find_backend_entry(module_name);
 190                 if (!entry) {
 191                         DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
 192                         goto fail;
 193                 }
 194         }
 195
 196         DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
 197
 198         handle = talloc_zero(conn, vfs_handle_struct);
 199         if (!handle) {
 200                 DEBUG(0,("TALLOC_ZERO() failed!\n"));
 201                 goto fail;
 202         }
 203         handle->conn = conn;
 204         handle->fns = entry->fns;
 205         if (module_param) {
 206                 handle->param = talloc_strdup(conn, module_param);
 207         }
 208         DLIST_ADD(conn->vfs_handles, handle);
 209
 210         SAFE_FREE(module_path);
 211         SAFE_FREE(module_name);
 212         return True;
 213
 214  fail:
 215         SAFE_FREE(module_path);
 216         SAFE_FREE(module_name);
 217         return False;
 218 }
 219
 220 /*****************************************************************
 221  Allow VFS modules to extend files_struct with VFS-specific state.
 222  This will be ok for small numbers of extensions, but might need to
 223  be refactored if it becomes more widely used.
 224 ******************************************************************/
 225
 226 #define EXT_DATA_AREA(e) ((uint8_t *)(e) + sizeof(struct vfs_fsp_data))
 227
 228 void *vfs_add_fsp_extension_notype(vfs_handle_struct *handle,
 229                                    files_struct *fsp, size_t ext_size,
 230                                    void (*destroy_fn)(void *p_data))
 231 {
 232         struct vfs_fsp_data *ext;
 233         void * ext_data;
 234
 235         /* Prevent VFS modules adding multiple extensions. */
 236         if ((ext_data = vfs_fetch_fsp_extension(handle, fsp))) {
 237                 return ext_data;
 238         }
 239
 240         ext = (struct vfs_fsp_data *)TALLOC_ZERO(
 241                 handle->conn, sizeof(struct vfs_fsp_data) + ext_size);
 242         if (ext == NULL) {
 243                 return NULL;
 244         }
 245
 246         ext->owner = handle;
 247         ext->next = fsp->vfs_extension;
 248         ext->destroy = destroy_fn;
 249         fsp->vfs_extension = ext;
 250         return EXT_DATA_AREA(ext);
 251 }
 252
 253 void vfs_remove_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
 254 {
 255         struct vfs_fsp_data *curr;
 256         struct vfs_fsp_data *prev;
 257
 258         for (curr = fsp->vfs_extension, prev = NULL;
 259              curr;
 260              prev = curr, curr = curr->next) {
 261                 if (curr->owner == handle) {
 262                     if (prev) {
 263                             prev->next = curr->next;
 264                     } else {
 265                             fsp->vfs_extension = curr->next;
 266                     }
 267                     if (curr->destroy) {
 268                             curr->destroy(EXT_DATA_AREA(curr));
 269                     }
 270                     TALLOC_FREE(curr);
 271                     return;
 272                 }
 273         }
 274 }
 275
 276 void vfs_remove_all_fsp_extensions(files_struct *fsp)
 277 {
 278         struct vfs_fsp_data *curr;
 279         struct vfs_fsp_data *next;
 280
 281         for (curr = fsp->vfs_extension; curr; curr = next) {
 282
 283                 next = curr->next;
 284                 fsp->vfs_extension = next;
 285
 286                 if (curr->destroy) {
 287                         curr->destroy(EXT_DATA_AREA(curr));
 288                 }
 289                 TALLOC_FREE(curr);
 290         }
 291 }
 292
 293 void *vfs_memctx_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
 294 {
 295         struct vfs_fsp_data *head;
 296
 297         for (head = fsp->vfs_extension; head; head = head->next) {
 298                 if (head->owner == handle) {
 299                         return head;
 300                 }
 301         }
 302
 303         return NULL;
 304 }
 305
 306 void *vfs_fetch_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
 307 {
 308         struct vfs_fsp_data *head;
 309
 310         head = (struct vfs_fsp_data *)vfs_memctx_fsp_extension(handle, fsp);
 311         if (head != NULL) {
 312                 return EXT_DATA_AREA(head);
 313         }
 314
 315         return NULL;
 316 }
 317
 318 #undef EXT_DATA_AREA
 319
 320 /*
 321  * Ensure this module catches all VFS functions.
 322  */
 323 #ifdef DEVELOPER
 324 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers* fns,
 325                             const char *module)
 326 {
 327         bool missing_fn = false;
 328         unsigned int idx;
 329         const uintptr_t *end = (const uintptr_t *)(fns + 1);
 330
 331         for (idx = 0; ((const uintptr_t *)fns + idx) < end; idx++) {
 332                 if (*((const uintptr_t *)fns + idx) == 0) {
 333                         DBG_ERR("VFS function at index %d not implemented "
 334                                 "in module %s\n", idx, module);
 335                         missing_fn = true;
 336                 }
 337         }
 338
 339         if (missing_fn) {
 340                 smb_panic("Required VFS function not implemented in module.\n");
 341         }
 342 }
 343 #else
 344 void smb_vfs_assert_all_fns(const struct vfs_fn_pointers* fns,
 345                             const char *module)
 346 {
 347 }
 348 #endif
 349
 350 /*****************************************************************
 351  Generic VFS init.
 352 ******************************************************************/
 353
 354 bool smbd_vfs_init(connection_struct *conn)
 355 {
 356         const char **vfs_objects;
 357         unsigned int i = 0;
 358         int j = 0;
 359
 360         /* Normal share - initialise with disk access functions */
 361         vfs_init_default(conn);
 362
 363         /* No need to load vfs modules for printer connections */
 364         if (conn->printer) {
 365                 return True;
 366         }
 367
 368         vfs_objects = lp_vfs_objects(SNUM(conn));
 369
 370         /* Override VFS functions if 'vfs object' was not specified*/
 371         if (!vfs_objects || !vfs_objects[0])
 372                 return True;
 373
 374         for (i=0; vfs_objects[i] ;) {
 375                 i++;
 376         }
 377
 378         for (j=i-1; j >= 0; j--) {
 379                 if (!vfs_init_custom(conn, vfs_objects[j])) {
 380                         DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
 381                         return False;
 382                 }
 383         }
 384         return True;
 385 }
 386
 387 /*******************************************************************
 388  Check if a file exists in the vfs.
 389 ********************************************************************/
 390
 391 NTSTATUS vfs_file_exist(connection_struct *conn, struct smb_filename *smb_fname)
 392 {
 393         /* Only return OK if stat was successful and S_ISREG */
 394         if ((SMB_VFS_STAT(conn, smb_fname) != -1) &&
 395             S_ISREG(smb_fname->st.st_ex_mode)) {
 396                 return NT_STATUS_OK;
 397         }
 398
 399         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 400 }
 401
 402 ssize_t vfs_pwrite_data(struct smb_request *req,
 403                         files_struct *fsp,
 404                         const char *buffer,
 405                         size_t N,
 406                         off_t offset)
 407 {
 408         size_t total=0;
 409         ssize_t ret;
 410
 411         if (req && req->unread_bytes) {
 412                 int sockfd = req->xconn->transport.sock;
 413                 SMB_ASSERT(req->unread_bytes == N);
 414                 /* VFS_RECVFILE must drain the socket
 415                  * before returning. */
 416                 req->unread_bytes = 0;
 417                 /*
 418                  * Leave the socket non-blocking and
 419                  * use SMB_VFS_RECVFILE. If it returns
 420                  * EAGAIN || EWOULDBLOCK temporarily set
 421                  * the socket blocking and retry
 422                  * the RECVFILE.
 423                  */
 424                 while (total < N) {
 425                         ret = SMB_VFS_RECVFILE(sockfd,
 426                                                 fsp,
 427                                                 offset + total,
 428                                                 N - total);
 429                         if (ret == 0 || (ret == -1 &&
 430                                          (errno == EAGAIN ||
 431                                           errno == EWOULDBLOCK))) {
 432                                 int old_flags;
 433                                 /* Ensure the socket is blocking. */
 434                                 old_flags = fcntl(sockfd, F_GETFL, 0);
 435                                 if (set_blocking(sockfd, true) == -1) {
 436                                         return (ssize_t)-1;
 437                                 }
 438                                 ret = SMB_VFS_RECVFILE(sockfd,
 439                                                         fsp,
 440                                                         offset + total,
 441                                                         N - total);
 442                                 if (fcntl(sockfd, F_SETFL, old_flags) == -1) {
 443                                         return (ssize_t)-1;
 444                                 }
 445                                 if (ret == -1) {
 446                                         return (ssize_t)-1;
 447                                 }
 448                                 total += ret;
 449                                 return (ssize_t)total;
 450                         }
 451                         /* Any other error case. */
 452                         if (ret == -1) {
 453                                 return ret;
 454                         }
 455                         total += ret;
 456                 }
 457                 return (ssize_t)total;
 458         }
 459
 460         while (total < N) {
 461                 ret = SMB_VFS_PWRITE(fsp, buffer + total, N - total,
 462                                      offset + total);
 463
 464                 if (ret == -1)
 465                         return -1;
 466                 if (ret == 0)
 467                         return total;
 468
 469                 total += ret;
 470         }
 471         return (ssize_t)total;
 472 }
 473 /****************************************************************************
 474  An allocate file space call using the vfs interface.
 475  Allocates space for a file from a filedescriptor.
 476  Returns 0 on success, -1 on failure.
 477 ****************************************************************************/
 478
 479 int vfs_allocate_file_space(files_struct *fsp, uint64_t len)
 480 {
 481         int ret;
 482         connection_struct *conn = fsp->conn;
 483         uint64_t space_avail;
 484         uint64_t bsize,dfree,dsize;
 485         NTSTATUS status;
 486
 487         /*
 488          * Actually try and commit the space on disk....
 489          */
 490
 491         DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n",
 492                   fsp_str_dbg(fsp), (double)len));
 493
 494         if (((off_t)len) < 0) {
 495                 DEBUG(0,("vfs_allocate_file_space: %s negative len "
 496                          "requested.\n", fsp_str_dbg(fsp)));
 497                 errno = EINVAL;
 498                 return -1;
 499         }
 500
 501         status = vfs_stat_fsp(fsp);
 502         if (!NT_STATUS_IS_OK(status)) {
 503                 return -1;
 504         }
 505
 506         if (len == (uint64_t)fsp->fsp_name->st.st_ex_size)
 507                 return 0;
 508
 509         if (len < (uint64_t)fsp->fsp_name->st.st_ex_size) {
 510                 /* Shrink - use ftruncate. */
 511
 512                 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current "
 513                           "size %.0f\n", fsp_str_dbg(fsp),
 514                           (double)fsp->fsp_name->st.st_ex_size));
 515
 516                 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_ALLOC_SHRINK);
 517
 518                 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
 519                 if ((ret = SMB_VFS_FTRUNCATE(fsp, (off_t)len)) != -1) {
 520                         set_filelen_write_cache(fsp, len);
 521                 }
 522
 523                 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_ALLOC_SHRINK);
 524
 525                 return ret;
 526         }
 527
 528         /* Grow - we need to test if we have enough space. */
 529
 530         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_ALLOC_GROW);
 531
 532         if (lp_strict_allocate(SNUM(fsp->conn))) {
 533                 /* See if we have a syscall that will allocate beyond
 534                    end-of-file without changing EOF. */
 535                 ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_FL_KEEP_SIZE,
 536                                         0, len);
 537         } else {
 538                 ret = 0;
 539         }
 540
 541         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_ALLOC_GROW);
 542
 543         if (ret == 0) {
 544                 /* We changed the allocation size on disk, but not
 545                    EOF - exactly as required. We're done ! */
 546                 return 0;
 547         }
 548
 549         if (ret == -1 && errno == ENOSPC) {
 550                 return -1;
 551         }
 552
 553         len -= fsp->fsp_name->st.st_ex_size;
 554         len /= 1024; /* Len is now number of 1k blocks needed. */
 555         space_avail =
 556             get_dfree_info(conn, fsp->fsp_name, &bsize, &dfree, &dsize);
 557         if (space_avail == (uint64_t)-1) {
 558                 return -1;
 559         }
 560
 561         DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
 562                   "needed blocks = %.0f, space avail = %.0f\n",
 563                   fsp_str_dbg(fsp), (double)fsp->fsp_name->st.st_ex_size, (double)len,
 564                   (double)space_avail));
 565
 566         if (len > space_avail) {
 567                 errno = ENOSPC;
 568                 return -1;
 569         }
 570
 571         return 0;
 572 }
 573
 574 /****************************************************************************
 575  A vfs set_filelen call.
 576  set the length of a file from a filedescriptor.
 577  Returns 0 on success, -1 on failure.
 578 ****************************************************************************/
 579
 580 int vfs_set_filelen(files_struct *fsp, off_t len)
 581 {
 582         int ret;
 583
 584         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
 585
 586         DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
 587                   fsp_str_dbg(fsp), (double)len));
 588         flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
 589         if ((ret = SMB_VFS_FTRUNCATE(fsp, len)) != -1) {
 590                 set_filelen_write_cache(fsp, len);
 591                 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
 592                              FILE_NOTIFY_CHANGE_SIZE
 593                              | FILE_NOTIFY_CHANGE_ATTRIBUTES,
 594                              fsp->fsp_name->base_name);
 595         }
 596
 597         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
 598
 599         return ret;
 600 }
 601
 602 /****************************************************************************
 603  A slow version of fallocate. Fallback code if SMB_VFS_FALLOCATE
 604  fails. Needs to be outside of the default version of SMB_VFS_FALLOCATE
 605  as this is also called from the default SMB_VFS_FTRUNCATE code.
 606  Always extends the file size.
 607  Returns 0 on success, -1 on failure.
 608 ****************************************************************************/
 609
 610 #define SPARSE_BUF_WRITE_SIZE (32*1024)
 611
 612 int vfs_slow_fallocate(files_struct *fsp, off_t offset, off_t len)
 613 {
 614         ssize_t pwrite_ret;
 615         size_t total = 0;
 616
 617         if (!sparse_buf) {
 618                 sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
 619                 if (!sparse_buf) {
 620                         errno = ENOMEM;
 621                         return -1;
 622                 }
 623         }
 624
 625         while (total < len) {
 626                 size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (len - total));
 627
 628                 pwrite_ret = SMB_VFS_PWRITE(fsp, sparse_buf, curr_write_size, offset + total);
 629                 if (pwrite_ret == -1) {
 630                         int saved_errno = errno;
 631                         DEBUG(10,("vfs_slow_fallocate: SMB_VFS_PWRITE for file "
 632                                   "%s failed with error %s\n",
 633                                   fsp_str_dbg(fsp), strerror(saved_errno)));
 634                         errno = saved_errno;
 635                         return -1;
 636                 }
 637                 total += pwrite_ret;
 638         }
 639
 640         return 0;
 641 }
 642
 643 /****************************************************************************
 644  A vfs fill sparse call.
 645  Writes zeros from the end of file to len, if len is greater than EOF.
 646  Used only by strict_sync.
 647  Returns 0 on success, -1 on failure.
 648 ****************************************************************************/
 649
 650 int vfs_fill_sparse(files_struct *fsp, off_t len)
 651 {
 652         int ret;
 653         NTSTATUS status;
 654         off_t offset;
 655         size_t num_to_write;
 656
 657         status = vfs_stat_fsp(fsp);
 658         if (!NT_STATUS_IS_OK(status)) {
 659                 return -1;
 660         }
 661
 662         if (len <= fsp->fsp_name->st.st_ex_size) {
 663                 return 0;
 664         }
 665
 666 #ifdef S_ISFIFO
 667         if (S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
 668                 return 0;
 669         }
 670 #endif
 671
 672         DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
 673                   "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp),
 674                   (double)fsp->fsp_name->st.st_ex_size, (double)len,
 675                   (double)(len - fsp->fsp_name->st.st_ex_size)));
 676
 677         contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_FILL_SPARSE);
 678
 679         flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
 680
 681         offset = fsp->fsp_name->st.st_ex_size;
 682         num_to_write = len - fsp->fsp_name->st.st_ex_size;
 683
 684         /* Only do this on non-stream file handles. */
 685         if (fsp->base_fsp == NULL) {
 686                 /* for allocation try fallocate first. This can fail on some
 687                  * platforms e.g. when the filesystem doesn't support it and no
 688                  * emulation is being done by the libc (like on AIX with JFS1). In that
 689                  * case we do our own emulation. fallocate implementations can
 690                  * return ENOTSUP or EINVAL in cases like that. */
 691                 ret = SMB_VFS_FALLOCATE(fsp, 0, offset, num_to_write);
 692                 if (ret == -1 && errno == ENOSPC) {
 693                         goto out;
 694                 }
 695                 if (ret == 0) {
 696                         goto out;
 697                 }
 698                 DEBUG(10,("vfs_fill_sparse: SMB_VFS_FALLOCATE failed with "
 699                         "error %d. Falling back to slow manual allocation\n", ret));
 700         }
 701
 702         ret = vfs_slow_fallocate(fsp, offset, num_to_write);
 703
 704  out:
 705
 706         if (ret == 0) {
 707                 set_filelen_write_cache(fsp, len);
 708         }
 709
 710         contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_FILL_SPARSE);
 711         return ret;
 712 }
 713
 714 /****************************************************************************
 715  Transfer some data (n bytes) between two file_struct's.
 716 ****************************************************************************/
 717
 718 static ssize_t vfs_pread_fn(void *file, void *buf, size_t len, off_t offset)
 719 {
 720         struct files_struct *fsp = (struct files_struct *)file;
 721
 722         return SMB_VFS_PREAD(fsp, buf, len, offset);
 723 }
 724
 725 static ssize_t vfs_pwrite_fn(void *file, const void *buf, size_t len, off_t offset)
 726 {
 727         struct files_struct *fsp = (struct files_struct *)file;
 728
 729         return SMB_VFS_PWRITE(fsp, buf, len, offset);
 730 }
 731
 732 off_t vfs_transfer_file(files_struct *in, files_struct *out, off_t n)
 733 {
 734         return transfer_file_internal((void *)in, (void *)out, n,
 735                                       vfs_pread_fn, vfs_pwrite_fn);
 736 }
 737
 738 /*******************************************************************
 739  A vfs_readdir wrapper which just returns the file name.
 740 ********************************************************************/
 741
 742 const char *vfs_readdirname(connection_struct *conn, void *p,
 743                             SMB_STRUCT_STAT *sbuf, char **talloced)
 744 {
 745         struct dirent *ptr= NULL;
 746         const char *dname;
 747         char *translated;
 748         NTSTATUS status;
 749
 750         if (!p)
 751                 return(NULL);
 752
 753         ptr = SMB_VFS_READDIR(conn, (DIR *)p, sbuf);
 754         if (!ptr)
 755                 return(NULL);
 756
 757         dname = ptr->d_name;
 758
 759
 760 #ifdef NEXT2
 761         if (telldir(p) < 0)
 762                 return(NULL);
 763 #endif
 764
 765 #ifdef HAVE_BROKEN_READDIR_NAME
 766         /* using /usr/ucb/cc is BAD */
 767         dname = dname - 2;
 768 #endif
 769
 770         status = SMB_VFS_TRANSLATE_NAME(conn, dname, vfs_translate_to_windows,
 771                                         talloc_tos(), &translated);
 772         if (NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) {
 773                 *talloced = NULL;
 774                 return dname;
 775         }
 776         *talloced = translated;
 777         if (!NT_STATUS_IS_OK(status)) {
 778                 return NULL;
 779         }
 780         return translated;
 781 }
 782
 783 /*******************************************************************
 784  A wrapper for vfs_chdir().
 785 ********************************************************************/
 786
 787 int vfs_ChDir(connection_struct *conn, const struct smb_filename *smb_fname)
 788 {
 789         int ret;
 790         struct smb_filename *old_cwd = conn->cwd_fname;
 791
 792         if (!LastDir) {
 793                 LastDir = SMB_STRDUP("");
 794         }
 795
 796         if (ISDOT(smb_fname->base_name)) {
 797                 return 0;
 798         }
 799
 800         if (*smb_fname->base_name == '/' &&
 801                         strcsequal(LastDir,smb_fname->base_name)) {
 802                 return 0;
 803         }
 804
 805         DEBUG(4,("vfs_ChDir to %s\n", smb_fname->base_name));
 806
 807         ret = SMB_VFS_CHDIR(conn, smb_fname);
 808         if (ret != 0) {
 809                 return -1;
 810         }
 811
 812         /*
 813          * Always replace conn->cwd_fname. We
 814          * don't know if it's been modified by
 815          * VFS modules in the stack.
 816          */
 817
 818         /* conn cache. */
 819         conn->cwd_fname = vfs_GetWd(conn, conn);
 820         if (conn->cwd_fname == NULL) {
 821                 /*
 822                  * vfs_GetWd() failed.
 823                  * We must be able to read cwd.
 824                  * Return to original directory
 825                  * and return -1.
 826                  */
 827                 int saved_errno = errno;
 828
 829                 if (old_cwd == NULL) {
 830                         /*
 831                          * Failed on the very first chdir()+getwd()
 832                          * for this connection. We can't
 833                          * continue.
 834                          */
 835                         smb_panic("conn->cwd getwd failed\n");
 836                         /* NOTREACHED */
 837                         return -1;
 838                 }
 839                 /* Restore original conn->cwd_fname. */
 840                 conn->cwd_fname = old_cwd;
 841
 842                 /* Return to the previous $cwd. */
 843                 ret = SMB_VFS_CHDIR(conn, conn->cwd_fname);
 844                 if (ret != 0) {
 845                         smb_panic("conn->cwd getwd failed\n");
 846                         /* NOTREACHED */
 847                         return -1;
 848                 }
 849                 errno = saved_errno;
 850                 /* And fail the chdir(). */
 851                 return -1;
 852         }
 853
 854         /* vfs_GetWd() succeeded. */
 855         /* Replace global cache. */
 856         SAFE_FREE(LastDir);
 857         LastDir = SMB_STRDUP(smb_fname->base_name);
 858
 859         DEBUG(4,("vfs_ChDir got %s\n", conn->cwd_fname->base_name));
 860
 861         TALLOC_FREE(old_cwd);
 862         return ret;
 863 }
 864
 865 /*******************************************************************
 866  Return the absolute current directory path - given a UNIX pathname.
 867  Note that this path is returned in DOS format, not UNIX
 868  format. Note this can be called with conn == NULL.
 869 ********************************************************************/
 870
 871 struct smb_filename *vfs_GetWd(TALLOC_CTX *ctx, connection_struct *conn)
 872 {
 873         struct smb_filename *current_dir_fname = NULL;
 874         struct file_id key;
 875         struct smb_filename *smb_fname_dot = NULL;
 876         struct smb_filename *smb_fname_full = NULL;
 877         struct smb_filename *result = NULL;
 878
 879         if (!lp_getwd_cache()) {
 880                 goto nocache;
 881         }
 882
 883         smb_fname_dot = synthetic_smb_fname(ctx, ".", NULL, NULL, 0);
 884         if (smb_fname_dot == NULL) {
 885                 errno = ENOMEM;
 886                 goto out;
 887         }
 888
 889         if (SMB_VFS_STAT(conn, smb_fname_dot) == -1) {
 890                 /*
 891                  * Known to fail for root: the directory may be NFS-mounted
 892                  * and exported with root_squash (so has no root access).
 893                  */
 894                 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
 895                          "(NFS problem ?)\n", strerror(errno) ));
 896                 goto nocache;
 897         }
 898
 899         key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
 900
 901         smb_fname_full = (struct smb_filename *)memcache_lookup_talloc(
 902                                         smbd_memcache(),
 903                                         GETWD_CACHE,
 904                                         data_blob_const(&key, sizeof(key)));
 905
 906         if (smb_fname_full == NULL) {
 907                 goto nocache;
 908         }
 909
 910         if ((SMB_VFS_STAT(conn, smb_fname_full) == 0) &&
 911             (smb_fname_dot->st.st_ex_dev == smb_fname_full->st.st_ex_dev) &&
 912             (smb_fname_dot->st.st_ex_ino == smb_fname_full->st.st_ex_ino) &&
 913             (S_ISDIR(smb_fname_dot->st.st_ex_mode))) {
 914                 /*
 915                  * Ok, we're done
 916                  * Note: smb_fname_full is owned by smbd_memcache()
 917                  * so we must make a copy to return.
 918                  */
 919                 result = cp_smb_filename(ctx, smb_fname_full);
 920                 if (result == NULL) {
 921                         errno = ENOMEM;
 922                 }
 923                 goto out;
 924         }
 925
 926  nocache:
 927
 928         /*
 929          * We don't have the information to hand so rely on traditional
 930          * methods. The very slow getcwd, which spawns a process on some
 931          * systems, or the not quite so bad getwd.
 932          */
 933
 934         current_dir_fname = SMB_VFS_GETWD(conn, ctx);
 935         if (current_dir_fname == NULL) {
 936                 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
 937                           strerror(errno)));
 938                 goto out;
 939         }
 940
 941         if (lp_getwd_cache() && VALID_STAT(smb_fname_dot->st)) {
 942                 key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
 943
 944                 /*
 945                  * smbd_memcache() will own current_dir_fname after the
 946                  * memcache_add_talloc call, so we must make
 947                  * a copy on ctx to return.
 948                  */
 949                 result = cp_smb_filename(ctx, current_dir_fname);
 950                 if (result == NULL) {
 951                         errno = ENOMEM;
 952                 }
 953
 954                 /*
 955                  * Ensure the memory going into the cache
 956                  * doesn't have a destructor so it can be
 957                  * cleanly freed.
 958                  */
 959                 talloc_set_destructor(current_dir_fname, NULL);
 960
 961                 memcache_add_talloc(smbd_memcache(),
 962                                 GETWD_CACHE,
 963                                 data_blob_const(&key, sizeof(key)),
 964                                 &current_dir_fname);
 965                 /* current_dir_fname is now == NULL here. */
 966         } else {
 967                 /* current_dir_fname is already allocated on ctx. */
 968                 result = current_dir_fname;
 969         }
 970
 971  out:
 972         TALLOC_FREE(smb_fname_dot);
 973         /*
 974          * Don't free current_dir_fname here. It's either been moved
 975          * to the memcache or is being returned in result.
 976          */
 977         return result;
 978 }
 979
 980 /*******************************************************************
 981  Reduce a file name, removing .. elements and checking that
 982  it is below dir in the hierarchy. This uses realpath.
 983  This function must run as root, and will return names
 984  and valid stat structs that can be checked on open.
 985 ********************************************************************/
 986
 987 NTSTATUS check_reduced_name_with_privilege(connection_struct *conn,
 988                         const struct smb_filename *smb_fname,
 989                         struct smb_request *smbreq)
 990 {
 991         NTSTATUS status;
 992         TALLOC_CTX *ctx = talloc_tos();
 993         const char *conn_rootdir;
 994         size_t rootdir_len;
 995         char *dir_name = NULL;
 996         char *resolved_name = NULL;
 997         const char *last_component = NULL;
 998         struct smb_filename *resolved_fname = NULL;
 999         struct smb_filename *saved_dir_fname = NULL;
1000         struct smb_filename *smb_fname_cwd = NULL;
1001         struct privilege_paths *priv_paths = NULL;
1002         int ret;
1003
1004         DEBUG(3,("check_reduced_name_with_privilege [%s] [%s]\n",
1005                         smb_fname->base_name,
1006                         conn->connectpath));
1007
1008
1009         priv_paths = talloc_zero(smbreq, struct privilege_paths);
1010         if (!priv_paths) {
1011                 status = NT_STATUS_NO_MEMORY;
1012                 goto err;
1013         }
1014
1015         if (!parent_dirname(ctx, smb_fname->base_name,
1016                         &dir_name, &last_component)) {
1017                 status = NT_STATUS_NO_MEMORY;
1018                 goto err;
1019         }
1020
1021         priv_paths->parent_name.base_name = talloc_strdup(priv_paths, dir_name);
1022         priv_paths->file_name.base_name = talloc_strdup(priv_paths, last_component);
1023
1024         if (priv_paths->parent_name.base_name == NULL ||
1025                         priv_paths->file_name.base_name == NULL) {
1026                 status = NT_STATUS_NO_MEMORY;
1027                 goto err;
1028         }
1029
1030         if (SMB_VFS_STAT(conn, &priv_paths->parent_name) != 0) {
1031                 status = map_nt_error_from_unix(errno);
1032                 goto err;
1033         }
1034         /* Remember where we were. */
1035         saved_dir_fname = vfs_GetWd(ctx, conn);
1036         if (!saved_dir_fname) {
1037                 status = map_nt_error_from_unix(errno);
1038                 goto err;
1039         }
1040
1041         if (vfs_ChDir(conn, &priv_paths->parent_name) == -1) {
1042                 status = map_nt_error_from_unix(errno);
1043                 goto err;
1044         }
1045
1046         smb_fname_cwd = synthetic_smb_fname(talloc_tos(), ".", NULL, NULL, 0);
1047         if (smb_fname_cwd == NULL) {
1048                 status = NT_STATUS_NO_MEMORY;
1049                 goto err;
1050         }
1051
1052         /* Get the absolute path of the parent directory. */
1053         resolved_fname = SMB_VFS_REALPATH(conn, ctx, smb_fname_cwd);
1054         if (resolved_fname == NULL) {
1055                 status = map_nt_error_from_unix(errno);
1056                 goto err;
1057         }
1058         resolved_name = resolved_fname->base_name;
1059
1060         if (*resolved_name != '/') {
1061                 DEBUG(0,("check_reduced_name_with_privilege: realpath "
1062                         "doesn't return absolute paths !\n"));
1063                 status = NT_STATUS_OBJECT_NAME_INVALID;
1064                 goto err;
1065         }
1066
1067         DEBUG(10,("check_reduced_name_with_privilege: realpath [%s] -> [%s]\n",
1068                 priv_paths->parent_name.base_name,
1069                 resolved_name));
1070
1071         /* Now check the stat value is the same. */
1072         if (SMB_VFS_LSTAT(conn, smb_fname_cwd) != 0) {
1073                 status = map_nt_error_from_unix(errno);
1074                 goto err;
1075         }
1076
1077         /* Ensure we're pointing at the same place. */
1078         if (!check_same_stat(&smb_fname_cwd->st, &priv_paths->parent_name.st)) {
1079                 DEBUG(0,("check_reduced_name_with_privilege: "
1080                         "device/inode/uid/gid on directory %s changed. "
1081                         "Denying access !\n",
1082                         priv_paths->parent_name.base_name));
1083                 status = NT_STATUS_ACCESS_DENIED;
1084                 goto err;
1085         }
1086
1087         /* Ensure we're below the connect path. */
1088
1089         conn_rootdir = SMB_VFS_CONNECTPATH(conn, smb_fname);
1090         if (conn_rootdir == NULL) {
1091                 DEBUG(2, ("check_reduced_name_with_privilege: Could not get "
1092                         "conn_rootdir\n"));
1093                 status = NT_STATUS_ACCESS_DENIED;
1094                 goto err;
1095         }
1096
1097         rootdir_len = strlen(conn_rootdir);
1098
1099         /*
1100          * In the case of rootdir_len == 1, we know that conn_rootdir is
1101          * "/", and we also know that resolved_name starts with a slash.
1102          * So, in this corner case, resolved_name is automatically a
1103          * sub-directory of the conn_rootdir. Thus we can skip the string
1104          * comparison and the next character checks (which are even
1105          * wrong in this case).
1106          */
1107         if (rootdir_len != 1) {
1108                 bool matched;
1109
1110                 matched = (strncmp(conn_rootdir, resolved_name,
1111                                 rootdir_len) == 0);
1112
1113                 if (!matched || (resolved_name[rootdir_len] != '/' &&
1114                                  resolved_name[rootdir_len] != '\0')) {
1115                         DEBUG(2, ("check_reduced_name_with_privilege: Bad "
1116                                 "access attempt: %s is a symlink outside the "
1117                                 "share path\n",
1118                                 dir_name));
1119                         DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir));
1120                         DEBUGADD(2, ("resolved_name=%s\n", resolved_name));
1121                         status = NT_STATUS_ACCESS_DENIED;
1122                         goto err;
1123                 }
1124         }
1125
1126         /* Now ensure that the last component either doesn't
1127            exist, or is *NOT* a symlink. */
1128
1129         ret = SMB_VFS_LSTAT(conn, &priv_paths->file_name);
1130         if (ret == -1) {
1131                 /* Errno must be ENOENT for this be ok. */
1132                 if (errno != ENOENT) {
1133                         status = map_nt_error_from_unix(errno);
1134                         DEBUG(2, ("check_reduced_name_with_privilege: "
1135                                 "LSTAT on %s failed with %s\n",
1136                                 priv_paths->file_name.base_name,
1137                                 nt_errstr(status)));
1138                         goto err;
1139                 }
1140         }
1141
1142         if (VALID_STAT(priv_paths->file_name.st) &&
1143                         S_ISLNK(priv_paths->file_name.st.st_ex_mode)) {
1144                 DEBUG(2, ("check_reduced_name_with_privilege: "
1145                         "Last component %s is a symlink. Denying"
1146                         "access.\n",
1147                         priv_paths->file_name.base_name));
1148                 status = NT_STATUS_ACCESS_DENIED;
1149                 goto err;
1150         }
1151
1152         smbreq->priv_paths = priv_paths;
1153         status = NT_STATUS_OK;
1154
1155   err:
1156
1157         if (saved_dir_fname != NULL) {
1158                 vfs_ChDir(conn, saved_dir_fname);
1159                 TALLOC_FREE(saved_dir_fname);
1160         }
1161         TALLOC_FREE(resolved_fname);
1162         if (!NT_STATUS_IS_OK(status)) {
1163                 TALLOC_FREE(priv_paths);
1164         }
1165         TALLOC_FREE(dir_name);
1166         return status;
1167 }
1168
1169 /*******************************************************************
1170  Reduce a file name, removing .. elements and checking that
1171  it is below dir in the hierarchy. This uses realpath.
1172
1173  If cwd_name == NULL then fname is a client given path relative
1174  to the root path of the share.
1175
1176  If cwd_name != NULL then fname is a client given path relative
1177  to cwd_name. cwd_name is relative to the root path of the share.
1178 ********************************************************************/
1179
1180 NTSTATUS check_reduced_name(connection_struct *conn,
1181                                 const struct smb_filename *cwd_fname,
1182                                 const struct smb_filename *smb_fname)
1183 {
1184         TALLOC_CTX *ctx = talloc_tos();
1185         const char *cwd_name = cwd_fname ? cwd_fname->base_name : NULL;
1186         const char *fname = smb_fname->base_name;
1187         struct smb_filename *resolved_fname;
1188         char *resolved_name = NULL;
1189         char *new_fname = NULL;
1190         bool allow_symlinks = true;
1191         bool allow_widelinks = false;
1192
1193         DBG_DEBUG("check_reduced_name [%s] [%s]\n", fname, conn->connectpath);
1194
1195         resolved_fname = SMB_VFS_REALPATH(conn, ctx, smb_fname);
1196
1197         if (resolved_fname == NULL) {
1198                 switch (errno) {
1199                         case ENOTDIR:
1200                                 DEBUG(3,("check_reduced_name: Component not a "
1201                                          "directory in getting realpath for "
1202                                          "%s\n", fname));
1203                                 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1204                         case ENOENT:
1205                         {
1206                                 char *dir_name = NULL;
1207                                 struct smb_filename dir_fname = {0};
1208                                 const char *last_component = NULL;
1209
1210                                 /* Last component didn't exist.
1211                                    Remove it and try and canonicalise
1212                                    the directory name. */
1213                                 if (!parent_dirname(ctx, fname,
1214                                                 &dir_name,
1215                                                 &last_component)) {
1216                                         return NT_STATUS_NO_MEMORY;
1217                                 }
1218
1219                                 dir_fname = (struct smb_filename)
1220                                         { .base_name = dir_name };
1221                                 resolved_fname = SMB_VFS_REALPATH(conn,
1222                                                         ctx,
1223                                                         &dir_fname);
1224                                 if (resolved_fname == NULL) {
1225                                         NTSTATUS status = map_nt_error_from_unix(errno);
1226
1227                                         if (errno == ENOENT || errno == ENOTDIR) {
1228                                                 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
1229                                         }
1230
1231                                         DEBUG(3,("check_reduce_name: "
1232                                                  "couldn't get realpath for "
1233                                                  "%s (%s)\n",
1234                                                 fname,
1235                                                 nt_errstr(status)));
1236                                         return status;
1237                                 }
1238                                 resolved_name = talloc_asprintf(ctx,
1239                                                 "%s/%s",
1240                                                 resolved_fname->base_name,
1241                                                 last_component);
1242                                 if (resolved_name == NULL) {
1243                                         return NT_STATUS_NO_MEMORY;
1244                                 }
1245                                 break;
1246                         }
1247                         default:
1248                                 DEBUG(3,("check_reduced_name: couldn't get "
1249                                          "realpath for %s\n", fname));
1250                                 return map_nt_error_from_unix(errno);
1251                 }
1252         } else {
1253                 resolved_name = resolved_fname->base_name;
1254         }
1255
1256         DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname,
1257                   resolved_name));
1258
1259         if (*resolved_name != '/') {
1260                 DEBUG(0,("check_reduced_name: realpath doesn't return "
1261                          "absolute paths !\n"));
1262                 TALLOC_FREE(resolved_fname);
1263                 return NT_STATUS_OBJECT_NAME_INVALID;
1264         }
1265
1266         allow_widelinks = lp_widelinks(SNUM(conn));
1267         allow_symlinks = lp_follow_symlinks(SNUM(conn));
1268
1269         /* Common widelinks and symlinks checks. */
1270         if (!allow_widelinks || !allow_symlinks) {
1271                 const char *conn_rootdir;
1272                 size_t rootdir_len;
1273
1274                 conn_rootdir = SMB_VFS_CONNECTPATH(conn, smb_fname);
1275                 if (conn_rootdir == NULL) {
1276                         DEBUG(2, ("check_reduced_name: Could not get "
1277                                 "conn_rootdir\n"));
1278                         TALLOC_FREE(resolved_fname);
1279                         return NT_STATUS_ACCESS_DENIED;
1280                 }
1281
1282                 rootdir_len = strlen(conn_rootdir);
1283
1284                 /*
1285                  * In the case of rootdir_len == 1, we know that
1286                  * conn_rootdir is "/", and we also know that
1287                  * resolved_name starts with a slash.  So, in this
1288                  * corner case, resolved_name is automatically a
1289                  * sub-directory of the conn_rootdir. Thus we can skip
1290                  * the string comparison and the next character checks
1291                  * (which are even wrong in this case).
1292                  */
1293                 if (rootdir_len != 1) {
1294                         bool matched;
1295
1296                         matched = (strncmp(conn_rootdir, resolved_name,
1297                                         rootdir_len) == 0);
1298                         if (!matched || (resolved_name[rootdir_len] != '/' &&
1299                                          resolved_name[rootdir_len] != '\0')) {
1300                                 DEBUG(2, ("check_reduced_name: Bad access "
1301                                         "attempt: %s is a symlink outside the "
1302                                         "share path\n", fname));
1303                                 DEBUGADD(2, ("conn_rootdir =%s\n",
1304                                              conn_rootdir));
1305                                 DEBUGADD(2, ("resolved_name=%s\n",
1306                                              resolved_name));
1307                                 TALLOC_FREE(resolved_fname);
1308                                 return NT_STATUS_ACCESS_DENIED;
1309                         }
1310                 }
1311
1312                 /* Extra checks if all symlinks are disallowed. */
1313                 if (!allow_symlinks) {
1314                         /* fname can't have changed in resolved_path. */
1315                         const char *p = &resolved_name[rootdir_len];
1316
1317                         /*
1318                          * UNIX filesystem semantics, names consisting
1319                          * only of "." or ".." CANNOT be symlinks.
1320                          */
1321                         if (ISDOT(fname) || ISDOTDOT(fname)) {
1322                                 goto out;
1323                         }
1324
1325                         if (*p != '/') {
1326                                 DEBUG(2, ("check_reduced_name: logic error (%c) "
1327                                         "in resolved_name: %s\n",
1328                                         *p,
1329                                         fname));
1330                                 TALLOC_FREE(resolved_fname);
1331                                 return NT_STATUS_ACCESS_DENIED;
1332                         }
1333
1334                         p++;
1335
1336                         /*
1337                          * If cwd_name is present and not ".",
1338                          * then fname is relative to that, not
1339                          * the root of the share. Make sure the
1340                          * path we check is the one the client
1341                          * sent (cwd_name+fname).
1342                          */
1343                         if (cwd_name != NULL && !ISDOT(cwd_name)) {
1344                                 new_fname = talloc_asprintf(ctx,
1345                                                         "%s/%s",
1346                                                         cwd_name,
1347                                                         fname);
1348                                 if (new_fname == NULL) {
1349                                         TALLOC_FREE(resolved_fname);
1350                                         return NT_STATUS_NO_MEMORY;
1351                                 }
1352                                 fname = new_fname;
1353                         }
1354
1355                         if (strcmp(fname, p)!=0) {
1356                                 DEBUG(2, ("check_reduced_name: Bad access "
1357                                         "attempt: %s is a symlink to %s\n",
1358                                           fname, p));
1359                                 TALLOC_FREE(resolved_fname);
1360                                 TALLOC_FREE(new_fname);
1361                                 return NT_STATUS_ACCESS_DENIED;
1362                         }
1363                 }
1364         }
1365
1366   out:
1367
1368         DBG_INFO("%s reduced to %s\n", fname, resolved_name);
1369         TALLOC_FREE(resolved_fname);
1370         TALLOC_FREE(new_fname);
1371         return NT_STATUS_OK;
1372 }
1373
1374 /**
1375  * XXX: This is temporary and there should be no callers of this once
1376  * smb_filename is plumbed through all path based operations.
1377  *
1378  * Called when we know stream name parsing has already been done.
1379  */
1380 int vfs_stat_smb_basename(struct connection_struct *conn,
1381                         const struct smb_filename *smb_fname_in,
1382                         SMB_STRUCT_STAT *psbuf)
1383 {
1384         struct smb_filename smb_fname = {
1385                 .base_name = discard_const_p(char, smb_fname_in->base_name),
1386                 .flags = smb_fname_in->flags
1387         };
1388         int ret;
1389
1390         if (smb_fname.flags & SMB_FILENAME_POSIX_PATH) {
1391                 ret = SMB_VFS_LSTAT(conn, &smb_fname);
1392         } else {
1393                 ret = SMB_VFS_STAT(conn, &smb_fname);
1394         }
1395
1396         if (ret != -1) {
1397                 *psbuf = smb_fname.st;
1398         }
1399         return ret;
1400 }
1401
1402 /**
1403  * Ensure LSTAT is called for POSIX paths.
1404  */
1405
1406 NTSTATUS vfs_stat_fsp(files_struct *fsp)
1407 {
1408         int ret;
1409
1410         if(fsp->fh->fd == -1) {
1411                 if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
1412                         ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
1413                 } else {
1414                         ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
1415                 }
1416                 if (ret == -1) {
1417                         return map_nt_error_from_unix(errno);
1418                 }
1419         } else {
1420                 if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
1421                         return map_nt_error_from_unix(errno);
1422                 }
1423         }
1424         return NT_STATUS_OK;
1425 }
1426
1427 /**
1428  * Initialize num_streams and streams, then call VFS op streaminfo
1429  */
1430 NTSTATUS vfs_streaminfo(connection_struct *conn,
1431                         struct files_struct *fsp,
1432                         const struct smb_filename *smb_fname,
1433                         TALLOC_CTX *mem_ctx,
1434                         unsigned int *num_streams,
1435                         struct stream_struct **streams)
1436 {
1437         *num_streams = 0;
1438         *streams = NULL;
1439         return SMB_VFS_STREAMINFO(conn,
1440                         fsp,
1441                         smb_fname,
1442                         mem_ctx,
1443                         num_streams,
1444                         streams);
1445 }
1446
1447 /*
1448   generate a file_id from a stat structure
1449  */
1450 struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_STAT *sbuf)
1451 {
1452         return SMB_VFS_FILE_ID_CREATE(conn, sbuf);
1453 }
1454
1455 int smb_vfs_call_connect(struct vfs_handle_struct *handle,
1456                          const char *service, const char *user)
1457 {
1458         VFS_FIND(connect);
1459         return handle->fns->connect_fn(handle, service, user);
1460 }
1461
1462 void smb_vfs_call_disconnect(struct vfs_handle_struct *handle)
1463 {
1464         VFS_FIND(disconnect);
1465         handle->fns->disconnect_fn(handle);
1466 }
1467
1468 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle,
1469                                 const struct smb_filename *smb_fname,
1470                                 uint64_t *bsize,
1471                                 uint64_t *dfree,
1472                                 uint64_t *dsize)
1473 {
1474         VFS_FIND(disk_free);
1475         return handle->fns->disk_free_fn(handle, smb_fname,
1476                         bsize, dfree, dsize);
1477 }
1478
1479 int smb_vfs_call_get_quota(struct vfs_handle_struct *handle,
1480                                 const struct smb_filename *smb_fname,
1481                                 enum SMB_QUOTA_TYPE qtype,
1482                                 unid_t id,
1483                                 SMB_DISK_QUOTA *qt)
1484 {
1485         VFS_FIND(get_quota);
1486         return handle->fns->get_quota_fn(handle, smb_fname, qtype, id, qt);
1487 }
1488
1489 int smb_vfs_call_set_quota(struct vfs_handle_struct *handle,
1490                            enum SMB_QUOTA_TYPE qtype, unid_t id,
1491                            SMB_DISK_QUOTA *qt)
1492 {
1493         VFS_FIND(set_quota);
1494         return handle->fns->set_quota_fn(handle, qtype, id, qt);
1495 }
1496
1497 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle,
1498                                       struct files_struct *fsp,
1499                                       struct shadow_copy_data *shadow_copy_data,
1500                                       bool labels)
1501 {
1502         VFS_FIND(get_shadow_copy_data);
1503         return handle->fns->get_shadow_copy_data_fn(handle, fsp,
1504                                                     shadow_copy_data,
1505                                                     labels);
1506 }
1507 int smb_vfs_call_statvfs(struct vfs_handle_struct *handle,
1508                         const struct smb_filename *smb_fname,
1509                         struct vfs_statvfs_struct *statbuf)
1510 {
1511         VFS_FIND(statvfs);
1512         return handle->fns->statvfs_fn(handle, smb_fname, statbuf);
1513 }
1514
1515 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle,
1516                         enum timestamp_set_resolution *p_ts_res)
1517 {
1518         VFS_FIND(fs_capabilities);
1519         return handle->fns->fs_capabilities_fn(handle, p_ts_res);
1520 }
1521
1522 NTSTATUS smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct *handle,
1523                                         struct dfs_GetDFSReferral *r)
1524 {
1525         VFS_FIND(get_dfs_referrals);
1526         return handle->fns->get_dfs_referrals_fn(handle, r);
1527 }
1528
1529 DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle,
1530                                         const struct smb_filename *smb_fname,
1531                                         const char *mask,
1532                                         uint32_t attributes)
1533 {
1534         VFS_FIND(opendir);
1535         return handle->fns->opendir_fn(handle, smb_fname, mask, attributes);
1536 }
1537
1538 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle,
1539                                         struct files_struct *fsp,
1540                                         const char *mask,
1541                                         uint32_t attributes)
1542 {
1543         VFS_FIND(fdopendir);
1544         return handle->fns->fdopendir_fn(handle, fsp, mask, attributes);
1545 }
1546
1547 struct dirent *smb_vfs_call_readdir(struct vfs_handle_struct *handle,
1548                                               DIR *dirp,
1549                                               SMB_STRUCT_STAT *sbuf)
1550 {
1551         VFS_FIND(readdir);
1552         return handle->fns->readdir_fn(handle, dirp, sbuf);
1553 }
1554
1555 void smb_vfs_call_seekdir(struct vfs_handle_struct *handle,
1556                           DIR *dirp, long offset)
1557 {
1558         VFS_FIND(seekdir);
1559         handle->fns->seekdir_fn(handle, dirp, offset);
1560 }
1561
1562 long smb_vfs_call_telldir(struct vfs_handle_struct *handle,
1563                           DIR *dirp)
1564 {
1565         VFS_FIND(telldir);
1566         return handle->fns->telldir_fn(handle, dirp);
1567 }
1568
1569 void smb_vfs_call_rewind_dir(struct vfs_handle_struct *handle,
1570                              DIR *dirp)
1571 {
1572         VFS_FIND(rewind_dir);
1573         handle->fns->rewind_dir_fn(handle, dirp);
1574 }
1575
1576 int smb_vfs_call_mkdir(struct vfs_handle_struct *handle,
1577                         const struct smb_filename *smb_fname,
1578                         mode_t mode)
1579 {
1580         VFS_FIND(mkdir);
1581         return handle->fns->mkdir_fn(handle, smb_fname, mode);
1582 }
1583
1584 int smb_vfs_call_rmdir(struct vfs_handle_struct *handle,
1585                         const struct smb_filename *smb_fname)
1586 {
1587         VFS_FIND(rmdir);
1588         return handle->fns->rmdir_fn(handle, smb_fname);
1589 }
1590
1591 int smb_vfs_call_closedir(struct vfs_handle_struct *handle,
1592                           DIR *dir)
1593 {
1594         VFS_FIND(closedir);
1595         return handle->fns->closedir_fn(handle, dir);
1596 }
1597
1598 int smb_vfs_call_open(struct vfs_handle_struct *handle,
1599                       struct smb_filename *smb_fname, struct files_struct *fsp,
1600                       int flags, mode_t mode)
1601 {
1602         VFS_FIND(open);
1603         return handle->fns->open_fn(handle, smb_fname, fsp, flags, mode);
1604 }
1605
1606 NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle,
1607                                   struct smb_request *req,
1608                                   uint16_t root_dir_fid,
1609                                   struct smb_filename *smb_fname,
1610                                   uint32_t access_mask,
1611                                   uint32_t share_access,
1612                                   uint32_t create_disposition,
1613                                   uint32_t create_options,
1614                                   uint32_t file_attributes,
1615                                   uint32_t oplock_request,
1616                                   struct smb2_lease *lease,
1617                                   uint64_t allocation_size,
1618                                   uint32_t private_flags,
1619                                   struct security_descriptor *sd,
1620                                   struct ea_list *ea_list,
1621                                   files_struct **result,
1622                                   int *pinfo,
1623                                   const struct smb2_create_blobs *in_context_blobs,
1624                                   struct smb2_create_blobs *out_context_blobs)
1625 {
1626         VFS_FIND(create_file);
1627         return handle->fns->create_file_fn(
1628                 handle, req, root_dir_fid, smb_fname, access_mask,
1629                 share_access, create_disposition, create_options,
1630                 file_attributes, oplock_request, lease, allocation_size,
1631                 private_flags, sd, ea_list,
1632                 result, pinfo, in_context_blobs, out_context_blobs);
1633 }
1634
1635 int smb_vfs_call_close(struct vfs_handle_struct *handle,
1636                        struct files_struct *fsp)
1637 {
1638         VFS_FIND(close);
1639         return handle->fns->close_fn(handle, fsp);
1640 }
1641
1642 ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
1643                            struct files_struct *fsp, void *data, size_t n,
1644                            off_t offset)
1645 {
1646         VFS_FIND(pread);
1647         return handle->fns->pread_fn(handle, fsp, data, n, offset);
1648 }
1649
1650 struct smb_vfs_call_pread_state {
1651         ssize_t (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1652         ssize_t retval;
1653         struct vfs_aio_state vfs_aio_state;
1654 };
1655
1656 static void smb_vfs_call_pread_done(struct tevent_req *subreq);
1657
1658 struct tevent_req *smb_vfs_call_pread_send(struct vfs_handle_struct *handle,
1659                                            TALLOC_CTX *mem_ctx,
1660                                            struct tevent_context *ev,
1661                                            struct files_struct *fsp,
1662                                            void *data,
1663                                            size_t n, off_t offset)
1664 {
1665         struct tevent_req *req, *subreq;
1666         struct smb_vfs_call_pread_state *state;
1667
1668         req = tevent_req_create(mem_ctx, &state,
1669                                 struct smb_vfs_call_pread_state);
1670         if (req == NULL) {
1671                 return NULL;
1672         }
1673         VFS_FIND(pread_send);
1674         state->recv_fn = handle->fns->pread_recv_fn;
1675
1676         subreq = handle->fns->pread_send_fn(handle, state, ev, fsp, data, n,
1677                                             offset);
1678         if (tevent_req_nomem(subreq, req)) {
1679                 return tevent_req_post(req, ev);
1680         }
1681         tevent_req_set_callback(subreq, smb_vfs_call_pread_done, req);
1682         return req;
1683 }
1684
1685 static void smb_vfs_call_pread_done(struct tevent_req *subreq)
1686 {
1687         struct tevent_req *req = tevent_req_callback_data(
1688                 subreq, struct tevent_req);
1689         struct smb_vfs_call_pread_state *state = tevent_req_data(
1690                 req, struct smb_vfs_call_pread_state);
1691
1692         state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1693         TALLOC_FREE(subreq);
1694         if (state->retval == -1) {
1695                 tevent_req_error(req, state->vfs_aio_state.error);
1696                 return;
1697         }
1698         tevent_req_done(req);
1699 }
1700
1701 ssize_t SMB_VFS_PREAD_RECV(struct tevent_req *req,
1702                            struct vfs_aio_state *vfs_aio_state)
1703 {
1704         struct smb_vfs_call_pread_state *state = tevent_req_data(
1705                 req, struct smb_vfs_call_pread_state);
1706         ssize_t retval;
1707
1708         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1709                 tevent_req_received(req);
1710                 return -1;
1711         }
1712         *vfs_aio_state = state->vfs_aio_state;
1713         retval = state->retval;
1714         tevent_req_received(req);
1715         return retval;
1716 }
1717
1718 ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
1719                             struct files_struct *fsp, const void *data,
1720                             size_t n, off_t offset)
1721 {
1722         VFS_FIND(pwrite);
1723         return handle->fns->pwrite_fn(handle, fsp, data, n, offset);
1724 }
1725
1726 struct smb_vfs_call_pwrite_state {
1727         ssize_t (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1728         ssize_t retval;
1729         struct vfs_aio_state vfs_aio_state;
1730 };
1731
1732 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq);
1733
1734 struct tevent_req *smb_vfs_call_pwrite_send(struct vfs_handle_struct *handle,
1735                                             TALLOC_CTX *mem_ctx,
1736                                             struct tevent_context *ev,
1737                                             struct files_struct *fsp,
1738                                             const void *data,
1739                                             size_t n, off_t offset)
1740 {
1741         struct tevent_req *req, *subreq;
1742         struct smb_vfs_call_pwrite_state *state;
1743
1744         req = tevent_req_create(mem_ctx, &state,
1745                                 struct smb_vfs_call_pwrite_state);
1746         if (req == NULL) {
1747                 return NULL;
1748         }
1749         VFS_FIND(pwrite_send);
1750         state->recv_fn = handle->fns->pwrite_recv_fn;
1751
1752         subreq = handle->fns->pwrite_send_fn(handle, state, ev, fsp, data, n,
1753                                              offset);
1754         if (tevent_req_nomem(subreq, req)) {
1755                 return tevent_req_post(req, ev);
1756         }
1757         tevent_req_set_callback(subreq, smb_vfs_call_pwrite_done, req);
1758         return req;
1759 }
1760
1761 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq)
1762 {
1763         struct tevent_req *req = tevent_req_callback_data(
1764                 subreq, struct tevent_req);
1765         struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1766                 req, struct smb_vfs_call_pwrite_state);
1767
1768         state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1769         TALLOC_FREE(subreq);
1770         if (state->retval == -1) {
1771                 tevent_req_error(req, state->vfs_aio_state.error);
1772                 return;
1773         }
1774         tevent_req_done(req);
1775 }
1776
1777 ssize_t SMB_VFS_PWRITE_RECV(struct tevent_req *req,
1778                             struct vfs_aio_state *vfs_aio_state)
1779 {
1780         struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1781                 req, struct smb_vfs_call_pwrite_state);
1782         ssize_t retval;
1783
1784         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1785                 tevent_req_received(req);
1786                 return -1;
1787         }
1788         *vfs_aio_state = state->vfs_aio_state;
1789         retval = state->retval;
1790         tevent_req_received(req);
1791         return retval;
1792 }
1793
1794 off_t smb_vfs_call_lseek(struct vfs_handle_struct *handle,
1795                              struct files_struct *fsp, off_t offset,
1796                              int whence)
1797 {
1798         VFS_FIND(lseek);
1799         return handle->fns->lseek_fn(handle, fsp, offset, whence);
1800 }
1801
1802 ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
1803                               files_struct *fromfsp, const DATA_BLOB *header,
1804                               off_t offset, size_t count)
1805 {
1806         VFS_FIND(sendfile);
1807         return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset,
1808                                         count);
1809 }
1810
1811 ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
1812                               files_struct *tofsp, off_t offset,
1813                               size_t count)
1814 {
1815         VFS_FIND(recvfile);
1816         return handle->fns->recvfile_fn(handle, fromfd, tofsp, offset, count);
1817 }
1818
1819 int smb_vfs_call_rename(struct vfs_handle_struct *handle,
1820                         const struct smb_filename *smb_fname_src,
1821                         const struct smb_filename *smb_fname_dst)
1822 {
1823         VFS_FIND(rename);
1824         return handle->fns->rename_fn(handle, smb_fname_src, smb_fname_dst);
1825 }
1826
1827 struct smb_vfs_call_fsync_state {
1828         int (*recv_fn)(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state);
1829         int retval;
1830         struct vfs_aio_state vfs_aio_state;
1831 };
1832
1833 static void smb_vfs_call_fsync_done(struct tevent_req *subreq);
1834
1835 struct tevent_req *smb_vfs_call_fsync_send(struct vfs_handle_struct *handle,
1836                                            TALLOC_CTX *mem_ctx,
1837                                            struct tevent_context *ev,
1838                                            struct files_struct *fsp)
1839 {
1840         struct tevent_req *req, *subreq;
1841         struct smb_vfs_call_fsync_state *state;
1842
1843         req = tevent_req_create(mem_ctx, &state,
1844                                 struct smb_vfs_call_fsync_state);
1845         if (req == NULL) {
1846                 return NULL;
1847         }
1848         VFS_FIND(fsync_send);
1849         state->recv_fn = handle->fns->fsync_recv_fn;
1850
1851         subreq = handle->fns->fsync_send_fn(handle, state, ev, fsp);
1852         if (tevent_req_nomem(subreq, req)) {
1853                 return tevent_req_post(req, ev);
1854         }
1855         tevent_req_set_callback(subreq, smb_vfs_call_fsync_done, req);
1856         return req;
1857 }
1858
1859 static void smb_vfs_call_fsync_done(struct tevent_req *subreq)
1860 {
1861         struct tevent_req *req = tevent_req_callback_data(
1862                 subreq, struct tevent_req);
1863         struct smb_vfs_call_fsync_state *state = tevent_req_data(
1864                 req, struct smb_vfs_call_fsync_state);
1865
1866         state->retval = state->recv_fn(subreq, &state->vfs_aio_state);
1867         TALLOC_FREE(subreq);
1868         if (state->retval == -1) {
1869                 tevent_req_error(req, state->vfs_aio_state.error);
1870                 return;
1871         }
1872         tevent_req_done(req);
1873 }
1874
1875 int SMB_VFS_FSYNC_RECV(struct tevent_req *req, struct vfs_aio_state *vfs_aio_state)
1876 {
1877         struct smb_vfs_call_fsync_state *state = tevent_req_data(
1878                 req, struct smb_vfs_call_fsync_state);
1879         ssize_t retval;
1880
1881         if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
1882                 tevent_req_received(req);
1883                 return -1;
1884         }
1885         *vfs_aio_state = state->vfs_aio_state;
1886         retval = state->retval;
1887         tevent_req_received(req);
1888         return retval;
1889 }
1890
1891 /*
1892  * Synchronous version of fsync, built from backend
1893  * async VFS primitives. Uses a temporary sub-event
1894  * context (NOT NESTED).
1895  */
1896
1897 int smb_vfs_fsync_sync(files_struct *fsp)
1898 {
1899         TALLOC_CTX *frame = talloc_stackframe();
1900         struct tevent_req *req = NULL;
1901         struct vfs_aio_state aio_state = { 0 };
1902         int ret = -1;
1903         bool ok;
1904         struct tevent_context *ev = samba_tevent_context_init(frame);
1905
1906         if (ev == NULL) {
1907                 goto out;
1908         }
1909
1910         req = SMB_VFS_FSYNC_SEND(talloc_tos(), ev, fsp);
1911         if (req == NULL) {
1912                 goto out;
1913         }
1914
1915         ok = tevent_req_poll(req, ev);
1916         if (!ok) {
1917                 goto out;
1918         }
1919
1920         ret = SMB_VFS_FSYNC_RECV(req, &aio_state);
1921
1922   out:
1923
1924         TALLOC_FREE(frame);
1925         if (aio_state.error != 0) {
1926                 errno = aio_state.error;
1927         }
1928         return ret;
1929 }
1930
1931 int smb_vfs_call_stat(struct vfs_handle_struct *handle,
1932                       struct smb_filename *smb_fname)
1933 {
1934         VFS_FIND(stat);
1935         return handle->fns->stat_fn(handle, smb_fname);
1936 }
1937
1938 int smb_vfs_call_fstat(struct vfs_handle_struct *handle,
1939                        struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1940 {
1941         VFS_FIND(fstat);
1942         return handle->fns->fstat_fn(handle, fsp, sbuf);
1943 }
1944
1945 int smb_vfs_call_lstat(struct vfs_handle_struct *handle,
1946                        struct smb_filename *smb_filename)
1947 {
1948         VFS_FIND(lstat);
1949         return handle->fns->lstat_fn(handle, smb_filename);
1950 }
1951
1952 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle,
1953                                      struct files_struct *fsp,
1954                                      const SMB_STRUCT_STAT *sbuf)
1955 {
1956         VFS_FIND(get_alloc_size);
1957         return handle->fns->get_alloc_size_fn(handle, fsp, sbuf);
1958 }
1959
1960 int smb_vfs_call_unlink(struct vfs_handle_struct *handle,
1961                         const struct smb_filename *smb_fname)
1962 {
1963         VFS_FIND(unlink);
1964         return handle->fns->unlink_fn(handle, smb_fname);
1965 }
1966
1967 int smb_vfs_call_chmod(struct vfs_handle_struct *handle,
1968                         const struct smb_filename *smb_fname,
1969                         mode_t mode)
1970 {
1971         VFS_FIND(chmod);
1972         return handle->fns->chmod_fn(handle, smb_fname, mode);
1973 }
1974
1975 int smb_vfs_call_fchmod(struct vfs_handle_struct *handle,
1976                         struct files_struct *fsp, mode_t mode)
1977 {
1978         VFS_FIND(fchmod);
1979         return handle->fns->fchmod_fn(handle, fsp, mode);
1980 }
1981
1982 int smb_vfs_call_chown(struct vfs_handle_struct *handle,
1983                         const struct smb_filename *smb_fname,
1984                         uid_t uid,
1985                         gid_t gid)
1986 {
1987         VFS_FIND(chown);
1988         return handle->fns->chown_fn(handle, smb_fname, uid, gid);
1989 }
1990
1991 int smb_vfs_call_fchown(struct vfs_handle_struct *handle,
1992                         struct files_struct *fsp, uid_t uid, gid_t gid)
1993 {
1994         VFS_FIND(fchown);
1995         return handle->fns->fchown_fn(handle, fsp, uid, gid);
1996 }
1997
1998 int smb_vfs_call_lchown(struct vfs_handle_struct *handle,
1999                         const struct smb_filename *smb_fname,
2000                         uid_t uid,
2001                         gid_t gid)
2002 {
2003         VFS_FIND(lchown);
2004         return handle->fns->lchown_fn(handle, smb_fname, uid, gid);
2005 }
2006
2007 NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid)
2008 {
2009         int ret;
2010         bool as_root = false;
2011         NTSTATUS status;
2012
2013         if (fsp->fh->fd != -1) {
2014                 /* Try fchown. */
2015                 ret = SMB_VFS_FCHOWN(fsp, uid, gid);
2016                 if (ret == 0) {
2017                         return NT_STATUS_OK;
2018                 }
2019                 if (ret == -1 && errno != ENOSYS) {
2020                         return map_nt_error_from_unix(errno);
2021                 }
2022         }
2023
2024         as_root = (geteuid() == 0);
2025
2026         if (as_root) {
2027                 /*
2028                  * We are being asked to chown as root. Make
2029                  * sure we chdir() into the path to pin it,
2030                  * and always act using lchown to ensure we
2031                  * don't deref any symbolic links.
2032                  */
2033                 char *parent_dir = NULL;
2034                 const char *final_component = NULL;
2035                 struct smb_filename *local_smb_fname = NULL;
2036                 struct smb_filename parent_dir_fname = {0};
2037                 struct smb_filename *saved_dir_fname = NULL;
2038
2039                 saved_dir_fname = vfs_GetWd(talloc_tos(),fsp->conn);
2040                 if (!saved_dir_fname) {
2041                         status = map_nt_error_from_unix(errno);
2042                         DEBUG(0,("vfs_chown_fsp: failed to get "
2043                                 "current working directory. Error was %s\n",
2044                                 strerror(errno)));
2045                         return status;
2046                 }
2047
2048                 if (!parent_dirname(talloc_tos(),
2049                                 fsp->fsp_name->base_name,
2050                                 &parent_dir,
2051                                 &final_component)) {
2052                         return NT_STATUS_NO_MEMORY;
2053                 }
2054
2055                 parent_dir_fname = (struct smb_filename) {
2056                         .base_name = parent_dir,
2057                         .flags = fsp->fsp_name->flags
2058                 };
2059
2060                 /* cd into the parent dir to pin it. */
2061                 ret = vfs_ChDir(fsp->conn, &parent_dir_fname);
2062                 if (ret == -1) {
2063                         return map_nt_error_from_unix(errno);
2064                 }
2065
2066                 local_smb_fname = synthetic_smb_fname(talloc_tos(),
2067                                         final_component,
2068                                         NULL,
2069                                         NULL,
2070                                         fsp->fsp_name->flags);
2071                 if (local_smb_fname == NULL) {
2072                         status = NT_STATUS_NO_MEMORY;
2073                         goto out;
2074                 }
2075
2076                 /* Must use lstat here. */
2077                 ret = SMB_VFS_LSTAT(fsp->conn, local_smb_fname);
2078                 if (ret == -1) {
2079                         status = map_nt_error_from_unix(errno);
2080                         goto out;
2081                 }
2082
2083                 /* Ensure it matches the fsp stat. */
2084                 if (!check_same_stat(&local_smb_fname->st,
2085                                 &fsp->fsp_name->st)) {
2086                         status = NT_STATUS_ACCESS_DENIED;
2087                         goto out;
2088                 }
2089
2090                 ret = SMB_VFS_LCHOWN(fsp->conn,
2091                         local_smb_fname,
2092                         uid, gid);
2093
2094                 if (ret == 0) {
2095                         status = NT_STATUS_OK;
2096                 } else {
2097                         status = map_nt_error_from_unix(errno);
2098                 }
2099
2100   out:
2101
2102                 vfs_ChDir(fsp->conn, saved_dir_fname);
2103                 TALLOC_FREE(local_smb_fname);
2104                 TALLOC_FREE(saved_dir_fname);
2105                 TALLOC_FREE(parent_dir);
2106
2107                 return status;
2108         }
2109
2110         if (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) {
2111                 ret = SMB_VFS_LCHOWN(fsp->conn,
2112                         fsp->fsp_name,
2113                         uid, gid);
2114         } else {
2115                 ret = SMB_VFS_CHOWN(fsp->conn,
2116                         fsp->fsp_name,
2117                         uid, gid);
2118         }
2119
2120         if (ret == 0) {
2121                 status = NT_STATUS_OK;
2122         } else {
2123                 status = map_nt_error_from_unix(errno);
2124         }
2125         return status;
2126 }
2127
2128 int smb_vfs_call_chdir(struct vfs_handle_struct *handle,
2129                         const struct smb_filename *smb_fname)
2130 {
2131         VFS_FIND(chdir);
2132         return handle->fns->chdir_fn(handle, smb_fname);
2133 }
2134
2135 struct smb_filename *smb_vfs_call_getwd(struct vfs_handle_struct *handle,
2136                                 TALLOC_CTX *ctx)
2137 {
2138         VFS_FIND(getwd);
2139         return handle->fns->getwd_fn(handle, ctx);
2140 }
2141
2142 int smb_vfs_call_ntimes(struct vfs_handle_struct *handle,
2143                         const struct smb_filename *smb_fname,
2144                         struct smb_file_time *ft)
2145 {
2146         VFS_FIND(ntimes);
2147         return handle->fns->ntimes_fn(handle, smb_fname, ft);
2148 }
2149
2150 int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
2151                            struct files_struct *fsp, off_t offset)
2152 {
2153         VFS_FIND(ftruncate);
2154         return handle->fns->ftruncate_fn(handle, fsp, offset);
2155 }
2156
2157 int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
2158                            struct files_struct *fsp,
2159                            uint32_t mode,
2160                            off_t offset,
2161                            off_t len)
2162 {
2163         VFS_FIND(fallocate);
2164         return handle->fns->fallocate_fn(handle, fsp, mode, offset, len);
2165 }
2166
2167 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
2168                               struct files_struct *fsp, uint32_t share_mode,
2169                               uint32_t access_mask)
2170 {
2171         VFS_FIND(kernel_flock);
2172         return handle->fns->kernel_flock_fn(handle, fsp, share_mode,
2173                                          access_mask);
2174 }
2175
2176 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
2177                                 struct files_struct *fsp, int leasetype)
2178 {
2179         VFS_FIND(linux_setlease);
2180         return handle->fns->linux_setlease_fn(handle, fsp, leasetype);
2181 }
2182
2183 int smb_vfs_call_symlink(struct vfs_handle_struct *handle,
2184                         const char *link_target,
2185                         const struct smb_filename *new_smb_fname)
2186 {
2187         VFS_FIND(symlink);
2188         return handle->fns->symlink_fn(handle, link_target, new_smb_fname);
2189 }
2190
2191 int smb_vfs_call_readlink(struct vfs_handle_struct *handle,
2192                         const struct smb_filename *smb_fname,
2193                         char *buf,
2194                         size_t bufsiz)
2195 {
2196         VFS_FIND(readlink);
2197         return handle->fns->readlink_fn(handle, smb_fname, buf, bufsiz);
2198 }
2199
2200 int smb_vfs_call_link(struct vfs_handle_struct *handle,
2201                         const struct smb_filename *old_smb_fname,
2202                         const struct smb_filename *new_smb_fname)
2203 {
2204         VFS_FIND(link);
2205         return handle->fns->link_fn(handle, old_smb_fname, new_smb_fname);
2206 }
2207
2208 int smb_vfs_call_mknod(struct vfs_handle_struct *handle,
2209                         const struct smb_filename *smb_fname,
2210                         mode_t mode,
2211                         SMB_DEV_T dev)
2212 {
2213         VFS_FIND(mknod);
2214         return handle->fns->mknod_fn(handle, smb_fname, mode, dev);
2215 }
2216
2217 struct smb_filename *smb_vfs_call_realpath(struct vfs_handle_struct *handle,
2218                         TALLOC_CTX *ctx,
2219                         const struct smb_filename *smb_fname)
2220 {
2221         VFS_FIND(realpath);
2222         return handle->fns->realpath_fn(handle, ctx, smb_fname);
2223 }
2224
2225 int smb_vfs_call_chflags(struct vfs_handle_struct *handle,
2226                         const struct smb_filename *smb_fname,
2227                         unsigned int flags)
2228 {
2229         VFS_FIND(chflags);
2230         return handle->fns->chflags_fn(handle, smb_fname, flags);
2231 }
2232
2233 struct file_id smb_vfs_call_file_id_create(struct vfs_handle_struct *handle,
2234                                            const SMB_STRUCT_STAT *sbuf)
2235 {
2236         VFS_FIND(file_id_create);
2237         return handle->fns->file_id_create_fn(handle, sbuf);
2238 }
2239
2240 uint64_t smb_vfs_call_fs_file_id(struct vfs_handle_struct *handle,
2241                                  const SMB_STRUCT_STAT *sbuf)
2242 {
2243         VFS_FIND(fs_file_id);
2244         return handle->fns->fs_file_id_fn(handle, sbuf);
2245 }
2246
2247 NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle,
2248                                  struct files_struct *fsp,
2249                                  const struct smb_filename *smb_fname,
2250                                  TALLOC_CTX *mem_ctx,
2251                                  unsigned int *num_streams,
2252                                  struct stream_struct **streams)
2253 {
2254         VFS_FIND(streaminfo);
2255         return handle->fns->streaminfo_fn(handle, fsp, smb_fname, mem_ctx,
2256                                           num_streams, streams);
2257 }
2258
2259 int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle,
2260                                    const char *path, const char *name,
2261                                    TALLOC_CTX *mem_ctx, char **found_name)
2262 {
2263         VFS_FIND(get_real_filename);
2264         return handle->fns->get_real_filename_fn(handle, path, name, mem_ctx,
2265                                                  found_name);
2266 }
2267
2268 const char *smb_vfs_call_connectpath(struct vfs_handle_struct *handle,
2269                                  const struct smb_filename *smb_fname)
2270 {
2271         VFS_FIND(connectpath);
2272         return handle->fns->connectpath_fn(handle, smb_fname);
2273 }
2274
2275 bool smb_vfs_call_strict_lock_check(struct vfs_handle_struct *handle,
2276                                     struct files_struct *fsp,
2277                                     struct lock_struct *plock)
2278 {
2279         VFS_FIND(strict_lock_check);
2280         return handle->fns->strict_lock_check_fn(handle, fsp, plock);
2281 }
2282
2283 NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
2284                                      const char *name,
2285                                      enum vfs_translate_direction direction,
2286                                      TALLOC_CTX *mem_ctx,
2287                                      char **mapped_name)
2288 {
2289         VFS_FIND(translate_name);
2290         return handle->fns->translate_name_fn(handle, name, direction, mem_ctx,
2291                                               mapped_name);
2292 }
2293
2294 NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle,
2295                             struct files_struct *fsp,
2296                             TALLOC_CTX *ctx,
2297                             uint32_t function,
2298                             uint16_t req_flags,
2299                             const uint8_t *in_data,
2300                             uint32_t in_len,
2301                             uint8_t **out_data,
2302                             uint32_t max_out_len,
2303                             uint32_t *out_len)
2304 {
2305         VFS_FIND(fsctl);
2306         return handle->fns->fsctl_fn(handle, fsp, ctx, function, req_flags,
2307                                      in_data, in_len, out_data, max_out_len,
2308                                      out_len);
2309 }
2310
2311 NTSTATUS smb_vfs_call_get_dos_attributes(struct vfs_handle_struct *handle,
2312                                          struct smb_filename *smb_fname,
2313                                          uint32_t *dosmode)
2314 {
2315         VFS_FIND(get_dos_attributes);
2316         return handle->fns->get_dos_attributes_fn(handle, smb_fname, dosmode);
2317 }
2318
2319 NTSTATUS smb_vfs_call_fget_dos_attributes(struct vfs_handle_struct *handle,
2320                                           struct files_struct *fsp,
2321                                           uint32_t *dosmode)
2322 {
2323         VFS_FIND(fget_dos_attributes);
2324         return handle->fns->fget_dos_attributes_fn(handle, fsp, dosmode);
2325 }
2326
2327 NTSTATUS smb_vfs_call_set_dos_attributes(struct vfs_handle_struct *handle,
2328                                          const struct smb_filename *smb_fname,
2329                                          uint32_t dosmode)
2330 {
2331         VFS_FIND(set_dos_attributes);
2332         return handle->fns->set_dos_attributes_fn(handle, smb_fname, dosmode);
2333 }
2334
2335 NTSTATUS smb_vfs_call_fset_dos_attributes(struct vfs_handle_struct *handle,
2336                                           struct files_struct *fsp,
2337                                           uint32_t dosmode)
2338 {
2339         VFS_FIND(set_dos_attributes);
2340         return handle->fns->fset_dos_attributes_fn(handle, fsp, dosmode);
2341 }
2342
2343 struct tevent_req *smb_vfs_call_offload_read_send(TALLOC_CTX *mem_ctx,
2344                                                   struct tevent_context *ev,
2345                                                   struct vfs_handle_struct *handle,
2346                                                   struct files_struct *fsp,
2347                                                   uint32_t fsctl,
2348                                                   uint32_t ttl,
2349                                                   off_t offset,
2350                                                   size_t to_copy)
2351 {
2352         VFS_FIND(offload_read_send);
2353         return handle->fns->offload_read_send_fn(mem_ctx, ev, handle,
2354                                                  fsp, fsctl,
2355                                                  ttl, offset, to_copy);
2356 }
2357
2358 NTSTATUS smb_vfs_call_offload_read_recv(struct tevent_req *req,
2359                                         struct vfs_handle_struct *handle,
2360                                         TALLOC_CTX *mem_ctx,
2361                                         DATA_BLOB *token_blob)
2362 {
2363         VFS_FIND(offload_read_recv);
2364         return handle->fns->offload_read_recv_fn(req, handle, mem_ctx, token_blob);
2365 }
2366
2367 struct tevent_req *smb_vfs_call_offload_write_send(struct vfs_handle_struct *handle,
2368                                                    TALLOC_CTX *mem_ctx,
2369                                                    struct tevent_context *ev,
2370                                                    uint32_t fsctl,
2371                                                    DATA_BLOB *token,
2372                                                    off_t transfer_offset,
2373                                                    struct files_struct *dest_fsp,
2374                                                    off_t dest_off,
2375                                                    off_t num)
2376 {
2377         VFS_FIND(offload_write_send);
2378         return handle->fns->offload_write_send_fn(handle, mem_ctx, ev, fsctl,
2379                                                token, transfer_offset,
2380                                                dest_fsp, dest_off, num);
2381 }
2382
2383 NTSTATUS smb_vfs_call_offload_write_recv(struct vfs_handle_struct *handle,
2384                                          struct tevent_req *req,
2385                                          off_t *copied)
2386 {
2387         VFS_FIND(offload_write_recv);
2388         return handle->fns->offload_write_recv_fn(handle, req, copied);
2389 }
2390
2391 struct smb_vfs_call_get_dos_attributes_state {
2392         files_struct *dir_fsp;
2393         NTSTATUS (*recv_fn)(struct tevent_req *req,
2394                             struct vfs_aio_state *aio_state,
2395                             uint32_t *dosmode);
2396         struct vfs_aio_state aio_state;
2397         uint32_t dos_attributes;
2398 };
2399
2400 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req *subreq);
2401
2402 struct tevent_req *smb_vfs_call_get_dos_attributes_send(
2403                         TALLOC_CTX *mem_ctx,
2404                         struct tevent_context *ev,
2405                         struct vfs_handle_struct *handle,
2406                         files_struct *dir_fsp,
2407                         struct smb_filename *smb_fname)
2408 {
2409         struct tevent_req *req = NULL;
2410         struct smb_vfs_call_get_dos_attributes_state *state = NULL;
2411         struct tevent_req *subreq = NULL;
2412
2413         req = tevent_req_create(mem_ctx, &state,
2414                                 struct smb_vfs_call_get_dos_attributes_state);
2415         if (req == NULL) {
2416                 return NULL;
2417         }
2418
2419         VFS_FIND(get_dos_attributes_send);
2420
2421         *state = (struct smb_vfs_call_get_dos_attributes_state) {
2422                 .dir_fsp = dir_fsp,
2423                 .recv_fn = handle->fns->get_dos_attributes_recv_fn,
2424         };
2425
2426         subreq = handle->fns->get_dos_attributes_send_fn(mem_ctx,
2427                                                          ev,
2428                                                          handle,
2429                                                          dir_fsp,
2430                                                          smb_fname);
2431         if (tevent_req_nomem(subreq, req)) {
2432                 return tevent_req_post(req, ev);
2433         }
2434         tevent_req_defer_callback(req, ev);
2435
2436         tevent_req_set_callback(subreq,
2437                                 smb_vfs_call_get_dos_attributes_done,
2438                                 req);
2439
2440         return req;
2441 }
2442
2443 static void smb_vfs_call_get_dos_attributes_done(struct tevent_req *subreq)
2444 {
2445         struct tevent_req *req =
2446                 tevent_req_callback_data(subreq,
2447                 struct tevent_req);
2448         struct smb_vfs_call_get_dos_attributes_state *state =
2449                 tevent_req_data(req,
2450                 struct smb_vfs_call_get_dos_attributes_state);
2451         NTSTATUS status;
2452         bool ok;
2453
2454         /*
2455          * Make sure we run as the user again
2456          */
2457         ok = change_to_user_by_fsp(state->dir_fsp);
2458         SMB_ASSERT(ok);
2459
2460         status = state->recv_fn(subreq,
2461                                 &state->aio_state,
2462                                 &state->dos_attributes);
2463         TALLOC_FREE(subreq);
2464         if (tevent_req_nterror(req, status)) {
2465                 return;
2466         }
2467
2468         tevent_req_done(req);
2469 }
2470
2471 NTSTATUS smb_vfs_call_get_dos_attributes_recv(
2472                 struct tevent_req *req,
2473                 struct vfs_aio_state *aio_state,
2474                 uint32_t *dos_attributes)
2475 {
2476         struct smb_vfs_call_get_dos_attributes_state *state =
2477                 tevent_req_data(req,
2478                 struct smb_vfs_call_get_dos_attributes_state);
2479         NTSTATUS status;
2480
2481         if (tevent_req_is_nterror(req, &status)) {
2482                 tevent_req_received(req);
2483                 return status;
2484         }
2485
2486         *aio_state = state->aio_state;
2487         *dos_attributes = state->dos_attributes;
2488         tevent_req_received(req);
2489         return NT_STATUS_OK;
2490 }
2491
2492 NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle,
2493                                       TALLOC_CTX *mem_ctx,
2494                                       struct files_struct *fsp,
2495                                       struct smb_filename *smb_fname,
2496                                       uint16_t *_compression_fmt)
2497 {
2498         VFS_FIND(get_compression);
2499         return handle->fns->get_compression_fn(handle, mem_ctx, fsp, smb_fname,
2500                                                _compression_fmt);
2501 }
2502
2503 NTSTATUS smb_vfs_call_set_compression(vfs_handle_struct *handle,
2504                                       TALLOC_CTX *mem_ctx,
2505                                       struct files_struct *fsp,
2506                                       uint16_t compression_fmt)
2507 {
2508         VFS_FIND(set_compression);
2509         return handle->fns->set_compression_fn(handle, mem_ctx, fsp,
2510                                                compression_fmt);
2511 }
2512
2513 NTSTATUS smb_vfs_call_snap_check_path(vfs_handle_struct *handle,
2514                                       TALLOC_CTX *mem_ctx,
2515                                       const char *service_path,
2516                                       char **base_volume)
2517 {
2518         VFS_FIND(snap_check_path);
2519         return handle->fns->snap_check_path_fn(handle, mem_ctx, service_path,
2520                                                base_volume);
2521 }
2522
2523 NTSTATUS smb_vfs_call_snap_create(struct vfs_handle_struct *handle,
2524                                   TALLOC_CTX *mem_ctx,
2525                                   const char *base_volume,
2526                                   time_t *tstamp,
2527                                   bool rw,
2528                                   char **base_path,
2529                                   char **snap_path)
2530 {
2531         VFS_FIND(snap_create);
2532         return handle->fns->snap_create_fn(handle, mem_ctx, base_volume, tstamp,
2533                                            rw, base_path, snap_path);
2534 }
2535
2536 NTSTATUS smb_vfs_call_snap_delete(struct vfs_handle_struct *handle,
2537                                   TALLOC_CTX *mem_ctx,
2538                                   char *base_path,
2539                                   char *snap_path)
2540 {
2541         VFS_FIND(snap_delete);
2542         return handle->fns->snap_delete_fn(handle, mem_ctx, base_path,
2543                                            snap_path);
2544 }
2545
2546 NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle,
2547                                   struct files_struct *fsp,
2548                                   uint32_t security_info,
2549                                   TALLOC_CTX *mem_ctx,
2550                                   struct security_descriptor **ppdesc)
2551 {
2552         VFS_FIND(fget_nt_acl);
2553         return handle->fns->fget_nt_acl_fn(handle, fsp, security_info,
2554                                            mem_ctx, ppdesc);
2555 }
2556
2557 NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle,
2558                                  const struct smb_filename *smb_fname,
2559                                  uint32_t security_info,
2560                                  TALLOC_CTX *mem_ctx,
2561                                  struct security_descriptor **ppdesc)
2562 {
2563         VFS_FIND(get_nt_acl);
2564         return handle->fns->get_nt_acl_fn(handle,
2565                                 smb_fname,
2566                                 security_info,
2567                                 mem_ctx,
2568                                 ppdesc);
2569 }
2570
2571 NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle,
2572                                   struct files_struct *fsp,
2573                                   uint32_t security_info_sent,
2574                                   const struct security_descriptor *psd)
2575 {
2576         VFS_FIND(fset_nt_acl);
2577         return handle->fns->fset_nt_acl_fn(handle, fsp, security_info_sent,
2578                                            psd);
2579 }
2580
2581 NTSTATUS smb_vfs_call_audit_file(struct vfs_handle_struct *handle,
2582                                  struct smb_filename *file,
2583                                  struct security_acl *sacl,
2584                                  uint32_t access_requested,
2585                                  uint32_t access_denied)
2586 {
2587         VFS_FIND(audit_file);
2588         return handle->fns->audit_file_fn(handle,
2589                                           file,
2590                                           sacl,
2591                                           access_requested,
2592                                           access_denied);
2593 }
2594
2595 SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle,
2596                                         const struct smb_filename *smb_fname,
2597                                         SMB_ACL_TYPE_T type,
2598                                         TALLOC_CTX *mem_ctx)
2599 {
2600         VFS_FIND(sys_acl_get_file);
2601         return handle->fns->sys_acl_get_file_fn(handle, smb_fname, type, mem_ctx);
2602 }
2603
2604 SMB_ACL_T smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct *handle,
2605                                       struct files_struct *fsp,
2606                                       TALLOC_CTX *mem_ctx)
2607 {
2608         VFS_FIND(sys_acl_get_fd);
2609         return handle->fns->sys_acl_get_fd_fn(handle, fsp, mem_ctx);
2610 }
2611
2612 int smb_vfs_call_sys_acl_blob_get_file(struct vfs_handle_struct *handle,
2613                                 const struct smb_filename *smb_fname,
2614                                 TALLOC_CTX *mem_ctx,
2615                                 char **blob_description,
2616                                 DATA_BLOB *blob)
2617 {
2618         VFS_FIND(sys_acl_blob_get_file);
2619         return handle->fns->sys_acl_blob_get_file_fn(handle, smb_fname,
2620                         mem_ctx, blob_description, blob);
2621 }
2622
2623 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct *handle,
2624                                      struct files_struct *fsp,
2625                                      TALLOC_CTX *mem_ctx,
2626                                      char **blob_description,
2627                                      DATA_BLOB *blob)
2628 {
2629         VFS_FIND(sys_acl_blob_get_fd);
2630         return handle->fns->sys_acl_blob_get_fd_fn(handle, fsp, mem_ctx, blob_description, blob);
2631 }
2632
2633 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle,
2634                                 const struct smb_filename *smb_fname,
2635                                 SMB_ACL_TYPE_T acltype,
2636                                 SMB_ACL_T theacl)
2637 {
2638         VFS_FIND(sys_acl_set_file);
2639         return handle->fns->sys_acl_set_file_fn(handle, smb_fname,
2640                                 acltype, theacl);
2641 }
2642
2643 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct *handle,
2644                                 struct files_struct *fsp, SMB_ACL_T theacl)
2645 {
2646         VFS_FIND(sys_acl_set_fd);
2647         return handle->fns->sys_acl_set_fd_fn(handle, fsp, theacl);
2648 }
2649
2650 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct *handle,
2651                                 const struct smb_filename *smb_fname)
2652 {
2653         VFS_FIND(sys_acl_delete_def_file);
2654         return handle->fns->sys_acl_delete_def_file_fn(handle, smb_fname);
2655 }
2656
2657 ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle,
2658                                 const struct smb_filename *smb_fname,
2659                                 const char *name,
2660                                 void *value,
2661                                 size_t size)
2662 {
2663         VFS_FIND(getxattr);
2664         return handle->fns->getxattr_fn(handle, smb_fname, name, value, size);
2665 }
2666
2667
2668 struct smb_vfs_call_getxattrat_state {
2669         files_struct *dir_fsp;
2670         ssize_t (*recv_fn)(struct tevent_req *req,
2671                            struct vfs_aio_state *aio_state,
2672                            TALLOC_CTX *mem_ctx,
2673                            uint8_t **xattr_value);
2674         ssize_t retval;
2675         uint8_t *xattr_value;
2676         struct vfs_aio_state aio_state;
2677 };
2678
2679 static void smb_vfs_call_getxattrat_done(struct tevent_req *subreq);
2680
2681 struct tevent_req *smb_vfs_call_getxattrat_send(
2682                         TALLOC_CTX *mem_ctx,
2683                         struct tevent_context *ev,
2684                         struct vfs_handle_struct *handle,
2685                         files_struct *dir_fsp,
2686                         const struct smb_filename *smb_fname,
2687                         const char *xattr_name,
2688                         size_t alloc_hint)
2689 {
2690         struct tevent_req *req = NULL;
2691         struct smb_vfs_call_getxattrat_state *state = NULL;
2692         struct tevent_req *subreq = NULL;
2693
2694         req = tevent_req_create(mem_ctx, &state,
2695                                 struct smb_vfs_call_getxattrat_state);
2696         if (req == NULL) {
2697                 return NULL;
2698         }
2699
2700         VFS_FIND(getxattrat_send);
2701
2702         *state = (struct smb_vfs_call_getxattrat_state) {
2703                 .dir_fsp = dir_fsp,
2704                 .recv_fn = handle->fns->getxattrat_recv_fn,
2705         };
2706
2707         subreq = handle->fns->getxattrat_send_fn(mem_ctx,
2708                                                  ev,
2709                                                  handle,
2710                                                  dir_fsp,
2711                                                  smb_fname,
2712                                                  xattr_name,
2713                                                  alloc_hint);
2714         if (tevent_req_nomem(subreq, req)) {
2715                 return tevent_req_post(req, ev);
2716         }
2717         tevent_req_defer_callback(req, ev);
2718
2719         tevent_req_set_callback(subreq, smb_vfs_call_getxattrat_done, req);
2720         return req;
2721 }
2722
2723 static void smb_vfs_call_getxattrat_done(struct tevent_req *subreq)
2724 {
2725         struct tevent_req *req = tevent_req_callback_data(
2726                 subreq, struct tevent_req);
2727         struct smb_vfs_call_getxattrat_state *state = tevent_req_data(
2728                 req, struct smb_vfs_call_getxattrat_state);
2729         bool ok;
2730
2731         /*
2732          * Make sure we run as the user again
2733          */
2734         ok = change_to_user_by_fsp(state->dir_fsp);
2735         SMB_ASSERT(ok);
2736
2737         state->retval = state->recv_fn(subreq,
2738                                        &state->aio_state,
2739                                        state,
2740                                        &state->xattr_value);
2741         TALLOC_FREE(subreq);
2742         if (state->retval == -1) {
2743                 tevent_req_error(req, state->aio_state.error);
2744                 return;
2745         }
2746
2747         tevent_req_done(req);
2748 }
2749
2750 ssize_t smb_vfs_call_getxattrat_recv(struct tevent_req *req,
2751                                      struct vfs_aio_state *aio_state,
2752                                      TALLOC_CTX *mem_ctx,
2753                                      uint8_t **xattr_value)
2754 {
2755         struct smb_vfs_call_getxattrat_state *state = tevent_req_data(
2756                 req, struct smb_vfs_call_getxattrat_state);
2757         size_t xattr_size;
2758
2759         if (tevent_req_is_unix_error(req, &aio_state->error)) {
2760                 tevent_req_received(req);
2761                 return -1;
2762         }
2763
2764         *aio_state = state->aio_state;
2765         xattr_size = state->retval;
2766         if (xattr_value != NULL) {
2767                 *xattr_value = talloc_move(mem_ctx, &state->xattr_value);
2768         }
2769
2770         tevent_req_received(req);
2771         return xattr_size;
2772 }
2773
2774 ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle,
2775                                struct files_struct *fsp, const char *name,
2776                                void *value, size_t size)
2777 {
2778         VFS_FIND(fgetxattr);
2779         return handle->fns->fgetxattr_fn(handle, fsp, name, value, size);
2780 }
2781
2782 ssize_t smb_vfs_call_listxattr(struct vfs_handle_struct *handle,
2783                                 const struct smb_filename *smb_fname,
2784                                 char *list,
2785                                 size_t size)
2786 {
2787         VFS_FIND(listxattr);
2788         return handle->fns->listxattr_fn(handle, smb_fname, list, size);
2789 }
2790
2791 ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle,
2792                                 struct files_struct *fsp, char *list,
2793                                 size_t size)
2794 {
2795         VFS_FIND(flistxattr);
2796         return handle->fns->flistxattr_fn(handle, fsp, list, size);
2797 }
2798
2799 int smb_vfs_call_removexattr(struct vfs_handle_struct *handle,
2800                                 const struct smb_filename *smb_fname,
2801                                 const char *name)
2802 {
2803         VFS_FIND(removexattr);
2804         return handle->fns->removexattr_fn(handle, smb_fname, name);
2805 }
2806
2807 int smb_vfs_call_fremovexattr(struct vfs_handle_struct *handle,
2808                               struct files_struct *fsp, const char *name)
2809 {
2810         VFS_FIND(fremovexattr);
2811         return handle->fns->fremovexattr_fn(handle, fsp, name);
2812 }
2813
2814 int smb_vfs_call_setxattr(struct vfs_handle_struct *handle,
2815                         const struct smb_filename *smb_fname,
2816                         const char *name,
2817                         const void *value,
2818                         size_t size,
2819                         int flags)
2820 {
2821         VFS_FIND(setxattr);
2822         return handle->fns->setxattr_fn(handle, smb_fname,
2823                         name, value, size, flags);
2824 }
2825
2826 int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle,
2827                            struct files_struct *fsp, const char *name,
2828                            const void *value, size_t size, int flags)
2829 {
2830         VFS_FIND(fsetxattr);
2831         return handle->fns->fsetxattr_fn(handle, fsp, name, value, size, flags);
2832 }
2833
2834 bool smb_vfs_call_aio_force(struct vfs_handle_struct *handle,
2835                             struct files_struct *fsp)
2836 {
2837         VFS_FIND(aio_force);
2838         return handle->fns->aio_force_fn(handle, fsp);
2839 }
2840
2841 NTSTATUS smb_vfs_call_durable_cookie(struct vfs_handle_struct *handle,
2842                                      struct files_struct *fsp,
2843                                      TALLOC_CTX *mem_ctx,
2844                                      DATA_BLOB *cookie)
2845 {
2846         VFS_FIND(durable_cookie);
2847         return handle->fns->durable_cookie_fn(handle, fsp, mem_ctx, cookie);
2848 }
2849
2850 NTSTATUS smb_vfs_call_durable_disconnect(struct vfs_handle_struct *handle,
2851                                          struct files_struct *fsp,
2852                                          const DATA_BLOB old_cookie,
2853                                          TALLOC_CTX *mem_ctx,
2854                                          DATA_BLOB *new_cookie)
2855 {
2856         VFS_FIND(durable_disconnect);
2857         return handle->fns->durable_disconnect_fn(handle, fsp, old_cookie,
2858                                                   mem_ctx, new_cookie);
2859 }
2860
2861 NTSTATUS smb_vfs_call_durable_reconnect(struct vfs_handle_struct *handle,
2862                                         struct smb_request *smb1req,
2863                                         struct smbXsrv_open *op,
2864                                         const DATA_BLOB old_cookie,
2865                                         TALLOC_CTX *mem_ctx,
2866                                         struct files_struct **fsp,
2867                                         DATA_BLOB *new_cookie)
2868 {
2869         VFS_FIND(durable_reconnect);
2870         return handle->fns->durable_reconnect_fn(handle, smb1req, op,
2871                                                  old_cookie, mem_ctx, fsp,
2872                                                  new_cookie);
2873 }
2874
2875 NTSTATUS smb_vfs_call_readdir_attr(struct vfs_handle_struct *handle,
2876                                    const struct smb_filename *fname,
2877                                    TALLOC_CTX *mem_ctx,
2878                                    struct readdir_attr_data **attr_data)
2879 {
2880         VFS_FIND(readdir_attr);
2881         return handle->fns->readdir_attr_fn(handle, fname, mem_ctx, attr_data);
2882 }