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