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