?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:vfs: add SMB_VFS_READDIR_ATTR()
[Samba.git] / source3 / smbd / vfs.c
blob4b9696393ab382b14d545244fb418dedd937395f
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 *)(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_KEEP_SIZE, 0, len);
577 } else {
578 ret = 0;
579 }
580
581 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_ALLOC_GROW);
582
583 if (ret == 0) {
584 /* We changed the allocation size on disk, but not
585 EOF - exactly as required. We're done ! */
586 return 0;
587 }
588
589 len -= fsp->fsp_name->st.st_ex_size;
590 len /= 1024; /* Len is now number of 1k blocks needed. */
591 space_avail = get_dfree_info(conn, fsp->fsp_name->base_name, false,
592 &bsize, &dfree, &dsize);
593 if (space_avail == (uint64_t)-1) {
594 return -1;
595 }
596
597 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, "
598 "needed blocks = %.0f, space avail = %.0f\n",
599 fsp_str_dbg(fsp), (double)fsp->fsp_name->st.st_ex_size, (double)len,
600 (double)space_avail));
601
602 if (len > space_avail) {
603 errno = ENOSPC;
604 return -1;
605 }
606
607 return 0;
608 }
609
610 /****************************************************************************
611 A vfs set_filelen call.
612 set the length of a file from a filedescriptor.
613 Returns 0 on success, -1 on failure.
614 ****************************************************************************/
615
616 int vfs_set_filelen(files_struct *fsp, off_t len)
617 {
618 int ret;
619
620 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
621
622 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n",
623 fsp_str_dbg(fsp), (double)len));
624 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
625 if ((ret = SMB_VFS_FTRUNCATE(fsp, len)) != -1) {
626 set_filelen_write_cache(fsp, len);
627 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
628 FILE_NOTIFY_CHANGE_SIZE
629 | FILE_NOTIFY_CHANGE_ATTRIBUTES,
630 fsp->fsp_name->base_name);
631 }
632
633 contend_level2_oplocks_end(fsp, LEVEL2_CONTEND_SET_FILE_LEN);
634
635 return ret;
636 }
637
638 /****************************************************************************
639 A slow version of fallocate. Fallback code if SMB_VFS_FALLOCATE
640 fails. Needs to be outside of the default version of SMB_VFS_FALLOCATE
641 as this is also called from the default SMB_VFS_FTRUNCATE code.
642 Always extends the file size.
643 Returns 0 on success, errno on failure.
644 ****************************************************************************/
645
646 #define SPARSE_BUF_WRITE_SIZE (32*1024)
647
648 int vfs_slow_fallocate(files_struct *fsp, off_t offset, off_t len)
649 {
650 ssize_t pwrite_ret;
651 size_t total = 0;
652
653 if (!sparse_buf) {
654 sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
655 if (!sparse_buf) {
656 errno = ENOMEM;
657 return ENOMEM;
658 }
659 }
660
661 while (total < len) {
662 size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (len - total));
663
664 pwrite_ret = SMB_VFS_PWRITE(fsp, sparse_buf, curr_write_size, offset + total);
665 if (pwrite_ret == -1) {
666 DEBUG(10,("vfs_slow_fallocate: SMB_VFS_PWRITE for file "
667 "%s failed with error %s\n",
668 fsp_str_dbg(fsp), strerror(errno)));
669 return errno;
670 }
671 total += pwrite_ret;
672 }
673
674 return 0;
675 }
676
677 /****************************************************************************
678 A vfs fill sparse call.
679 Writes zeros from the end of file to len, if len is greater than EOF.
680 Used only by strict_sync.
681 Returns 0 on success, -1 on failure.
682 ****************************************************************************/
683
684 int vfs_fill_sparse(files_struct *fsp, off_t len)
685 {
686 int ret;
687 NTSTATUS status;
688 off_t offset;
689 size_t num_to_write;
690
691 status = vfs_stat_fsp(fsp);
692 if (!NT_STATUS_IS_OK(status)) {
693 return -1;
694 }
695
696 if (len <= fsp->fsp_name->st.st_ex_size) {
697 return 0;
698 }
699
700 #ifdef S_ISFIFO
701 if (S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
702 return 0;
703 }
704 #endif
705
706 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to "
707 "len %.0f (%.0f bytes)\n", fsp_str_dbg(fsp),
708 (double)fsp->fsp_name->st.st_ex_size, (double)len,
709 (double)(len - fsp->fsp_name->st.st_ex_size)));
710
711 contend_level2_oplocks_begin(fsp, LEVEL2_CONTEND_FILL_SPARSE);
712
713 flush_write_cache(fsp, SAMBA_SIZECHANGE_FLUSH);
714
715 offset = fsp->fsp_name->st.st_ex_size;
716 num_to_write = len - fsp->fsp_name->st.st_ex_size;
717
718 /* Only do this on non-stream file handles. */
719 if (fsp->base_fsp == NULL) {
720 /* for allocation try fallocate first. This can fail on some
721 * platforms e.g. when the filesystem doesn't support it and no
722 * emulation is being done by the libc (like on AIX with JFS1). In that
723 * case we do our own emulation. fallocate implementations can
724 * return ENOTSUP or EINVAL in cases like that. */
725 ret = SMB_VFS_FALLOCATE(fsp, VFS_FALLOCATE_EXTEND_SIZE,
726 offset, num_to_write);
727 if (ret == ENOSPC) {
728 errno = ENOSPC;
729 ret = -1;
730 goto out;
731 }
732 if (ret == 0) {
733 goto out;
734 }
735 DEBUG(10,("vfs_fill_sparse: SMB_VFS_FALLOCATE failed with "
736 "error %d. Falling back to slow manual allocation\n", ret));
737 }
738
739 ret = vfs_slow_fallocate(fsp, offset, num_to_write);
740 if (ret != 0) {
741 errno = ret;
742 ret = -1;
743 }
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_read_fn(void *file, void *buf, size_t len)
760 {
761 struct files_struct *fsp = (struct files_struct *)file;
762
763 return SMB_VFS_READ(fsp, buf, len);
764 }
765
766 static ssize_t vfs_write_fn(void *file, const void *buf, size_t len)
767 {
768 struct files_struct *fsp = (struct files_struct *)file;
769
770 return SMB_VFS_WRITE(fsp, buf, len);
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_read_fn, vfs_write_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 if (strncmp(conn_rootdir, resolved_name, rootdir_len) != 0) {
1080 DEBUG(2, ("check_reduced_name_with_privilege: Bad access "
1081 "attempt: %s is a symlink outside the "
1082 "share path\n",
1083 dir_name));
1084 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir));
1085 DEBUGADD(2, ("resolved_name=%s\n", resolved_name));
1086 status = NT_STATUS_ACCESS_DENIED;
1087 goto err;
1088 }
1089
1090 /* Now ensure that the last component either doesn't
1091 exist, or is *NOT* a symlink. */
1092
1093 ret = SMB_VFS_LSTAT(conn, &priv_paths->file_name);
1094 if (ret == -1) {
1095 /* Errno must be ENOENT for this be ok. */
1096 if (errno != ENOENT) {
1097 status = map_nt_error_from_unix(errno);
1098 DEBUG(2, ("check_reduced_name_with_privilege: "
1099 "LSTAT on %s failed with %s\n",
1100 priv_paths->file_name.base_name,
1101 nt_errstr(status)));
1102 goto err;
1103 }
1104 }
1105
1106 if (VALID_STAT(priv_paths->file_name.st) &&
1107 S_ISLNK(priv_paths->file_name.st.st_ex_mode)) {
1108 DEBUG(2, ("check_reduced_name_with_privilege: "
1109 "Last component %s is a symlink. Denying"
1110 "access.\n",
1111 priv_paths->file_name.base_name));
1112 status = NT_STATUS_ACCESS_DENIED;
1113 goto err;
1114 }
1115
1116 smbreq->priv_paths = priv_paths;
1117 status = NT_STATUS_OK;
1118
1119 err:
1120
1121 if (saved_dir) {
1122 vfs_ChDir(conn, saved_dir);
1123 }
1124 SAFE_FREE(resolved_name);
1125 if (!NT_STATUS_IS_OK(status)) {
1126 TALLOC_FREE(priv_paths);
1127 }
1128 TALLOC_FREE(dir_name);
1129 return status;
1130 }
1131
1132 /*******************************************************************
1133 Reduce a file name, removing .. elements and checking that
1134 it is below dir in the heirachy. This uses realpath.
1135 ********************************************************************/
1136
1137 NTSTATUS check_reduced_name(connection_struct *conn, const char *fname)
1138 {
1139 char *resolved_name = NULL;
1140 bool allow_symlinks = true;
1141 bool allow_widelinks = false;
1142
1143 DEBUG(3,("check_reduced_name [%s] [%s]\n", fname, conn->connectpath));
1144
1145 resolved_name = SMB_VFS_REALPATH(conn,fname);
1146
1147 if (!resolved_name) {
1148 switch (errno) {
1149 case ENOTDIR:
1150 DEBUG(3,("check_reduced_name: Component not a "
1151 "directory in getting realpath for "
1152 "%s\n", fname));
1153 return NT_STATUS_OBJECT_PATH_NOT_FOUND;
1154 case ENOENT:
1155 {
1156 TALLOC_CTX *ctx = talloc_tos();
1157 char *dir_name = NULL;
1158 const char *last_component = NULL;
1159 char *new_name = NULL;
1160 int ret;
1161
1162 /* Last component didn't exist.
1163 Remove it and try and canonicalise
1164 the directory name. */
1165 if (!parent_dirname(ctx, fname,
1166 &dir_name,
1167 &last_component)) {
1168 return NT_STATUS_NO_MEMORY;
1169 }
1170
1171 resolved_name = SMB_VFS_REALPATH(conn,dir_name);
1172 if (!resolved_name) {
1173 NTSTATUS status = map_nt_error_from_unix(errno);
1174
1175 if (errno == ENOENT || errno == ENOTDIR) {
1176 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
1177 }
1178
1179 DEBUG(3,("check_reduce_name: "
1180 "couldn't get realpath for "
1181 "%s (%s)\n",
1182 fname,
1183 nt_errstr(status)));
1184 return status;
1185 }
1186 ret = asprintf(&new_name, "%s/%s",
1187 resolved_name, last_component);
1188 SAFE_FREE(resolved_name);
1189 if (ret == -1) {
1190 return NT_STATUS_NO_MEMORY;
1191 }
1192 resolved_name = new_name;
1193 break;
1194 }
1195 default:
1196 DEBUG(3,("check_reduced_name: couldn't get "
1197 "realpath for %s\n", fname));
1198 return map_nt_error_from_unix(errno);
1199 }
1200 }
1201
1202 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname,
1203 resolved_name));
1204
1205 if (*resolved_name != '/') {
1206 DEBUG(0,("check_reduced_name: realpath doesn't return "
1207 "absolute paths !\n"));
1208 SAFE_FREE(resolved_name);
1209 return NT_STATUS_OBJECT_NAME_INVALID;
1210 }
1211
1212 allow_widelinks = lp_widelinks(SNUM(conn));
1213 allow_symlinks = lp_follow_symlinks(SNUM(conn));
1214
1215 /* Common widelinks and symlinks checks. */
1216 if (!allow_widelinks || !allow_symlinks) {
1217 const char *conn_rootdir;
1218 size_t rootdir_len;
1219
1220 conn_rootdir = SMB_VFS_CONNECTPATH(conn, fname);
1221 if (conn_rootdir == NULL) {
1222 DEBUG(2, ("check_reduced_name: Could not get "
1223 "conn_rootdir\n"));
1224 SAFE_FREE(resolved_name);
1225 return NT_STATUS_ACCESS_DENIED;
1226 }
1227
1228 rootdir_len = strlen(conn_rootdir);
1229 if (strncmp(conn_rootdir, resolved_name,
1230 rootdir_len) != 0) {
1231 DEBUG(2, ("check_reduced_name: Bad access "
1232 "attempt: %s is a symlink outside the "
1233 "share path\n", fname));
1234 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir));
1235 DEBUGADD(2, ("resolved_name=%s\n", resolved_name));
1236 SAFE_FREE(resolved_name);
1237 return NT_STATUS_ACCESS_DENIED;
1238 }
1239
1240 /* Extra checks if all symlinks are disallowed. */
1241 if (!allow_symlinks) {
1242 /* fname can't have changed in resolved_path. */
1243 const char *p = &resolved_name[rootdir_len];
1244
1245 /* *p can be '\0' if fname was "." */
1246 if (*p == '\0' && ISDOT(fname)) {
1247 goto out;
1248 }
1249
1250 if (*p != '/') {
1251 DEBUG(2, ("check_reduced_name: logic error (%c) "
1252 "in resolved_name: %s\n",
1253 *p,
1254 fname));
1255 SAFE_FREE(resolved_name);
1256 return NT_STATUS_ACCESS_DENIED;
1257 }
1258
1259 p++;
1260 if (strcmp(fname, p)!=0) {
1261 DEBUG(2, ("check_reduced_name: Bad access "
1262 "attempt: %s is a symlink to %s\n",
1263 fname, p));
1264 SAFE_FREE(resolved_name);
1265 return NT_STATUS_ACCESS_DENIED;
1266 }
1267 }
1268 }
1269
1270 out:
1271
1272 DEBUG(3,("check_reduced_name: %s reduced to %s\n", fname,
1273 resolved_name));
1274 SAFE_FREE(resolved_name);
1275 return NT_STATUS_OK;
1276 }
1277
1278 /**
1279 * XXX: This is temporary and there should be no callers of this once
1280 * smb_filename is plumbed through all path based operations.
1281 */
1282 int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
1283 SMB_STRUCT_STAT *psbuf)
1284 {
1285 struct smb_filename *smb_fname;
1286 int ret;
1287
1288 smb_fname = synthetic_smb_fname_split(talloc_tos(), fname, NULL);
1289 if (smb_fname == NULL) {
1290 errno = ENOMEM;
1291 return -1;
1292 }
1293
1294 if (lp_posix_pathnames()) {
1295 ret = SMB_VFS_LSTAT(conn, smb_fname);
1296 } else {
1297 ret = SMB_VFS_STAT(conn, smb_fname);
1298 }
1299
1300 if (ret != -1) {
1301 *psbuf = smb_fname->st;
1302 }
1303
1304 TALLOC_FREE(smb_fname);
1305 return ret;
1306 }
1307
1308 /**
1309 * XXX: This is temporary and there should be no callers of this once
1310 * smb_filename is plumbed through all path based operations.
1311 */
1312 int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
1313 SMB_STRUCT_STAT *psbuf)
1314 {
1315 struct smb_filename *smb_fname;
1316 int ret;
1317
1318 smb_fname = synthetic_smb_fname_split(talloc_tos(), fname, NULL);
1319 if (smb_fname == NULL) {
1320 errno = ENOMEM;
1321 return -1;
1322 }
1323
1324 ret = SMB_VFS_LSTAT(conn, smb_fname);
1325 if (ret != -1) {
1326 *psbuf = smb_fname->st;
1327 }
1328
1329 TALLOC_FREE(smb_fname);
1330 return ret;
1331 }
1332
1333 /**
1334 * Ensure LSTAT is called for POSIX paths.
1335 */
1336
1337 NTSTATUS vfs_stat_fsp(files_struct *fsp)
1338 {
1339 int ret;
1340
1341 if(fsp->fh->fd == -1) {
1342 if (fsp->posix_open) {
1343 ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
1344 } else {
1345 ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
1346 }
1347 if (ret == -1) {
1348 return map_nt_error_from_unix(errno);
1349 }
1350 } else {
1351 if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
1352 return map_nt_error_from_unix(errno);
1353 }
1354 }
1355 return NT_STATUS_OK;
1356 }
1357
1358 /**
1359 * Initialize num_streams and streams, then call VFS op streaminfo
1360 */
1361 NTSTATUS vfs_streaminfo(connection_struct *conn,
1362 struct files_struct *fsp,
1363 const char *fname,
1364 TALLOC_CTX *mem_ctx,
1365 unsigned int *num_streams,
1366 struct stream_struct **streams)
1367 {
1368 *num_streams = 0;
1369 *streams = NULL;
1370 return SMB_VFS_STREAMINFO(conn, fsp, fname, mem_ctx, num_streams, streams);
1371 }
1372
1373 /*
1374 generate a file_id from a stat structure
1375 */
1376 struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_STAT *sbuf)
1377 {
1378 return SMB_VFS_FILE_ID_CREATE(conn, sbuf);
1379 }
1380
1381 int smb_vfs_call_connect(struct vfs_handle_struct *handle,
1382 const char *service, const char *user)
1383 {
1384 VFS_FIND(connect);
1385 return handle->fns->connect_fn(handle, service, user);
1386 }
1387
1388 void smb_vfs_call_disconnect(struct vfs_handle_struct *handle)
1389 {
1390 VFS_FIND(disconnect);
1391 handle->fns->disconnect_fn(handle);
1392 }
1393
1394 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle,
1395 const char *path, bool small_query,
1396 uint64_t *bsize, uint64_t *dfree,
1397 uint64_t *dsize)
1398 {
1399 VFS_FIND(disk_free);
1400 return handle->fns->disk_free_fn(handle, path, small_query, bsize,
1401 dfree, dsize);
1402 }
1403
1404 int smb_vfs_call_get_quota(struct vfs_handle_struct *handle,
1405 enum SMB_QUOTA_TYPE qtype, unid_t id,
1406 SMB_DISK_QUOTA *qt)
1407 {
1408 VFS_FIND(get_quota);
1409 return handle->fns->get_quota_fn(handle, qtype, id, qt);
1410 }
1411
1412 int smb_vfs_call_set_quota(struct vfs_handle_struct *handle,
1413 enum SMB_QUOTA_TYPE qtype, unid_t id,
1414 SMB_DISK_QUOTA *qt)
1415 {
1416 VFS_FIND(set_quota);
1417 return handle->fns->set_quota_fn(handle, qtype, id, qt);
1418 }
1419
1420 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle,
1421 struct files_struct *fsp,
1422 struct shadow_copy_data *shadow_copy_data,
1423 bool labels)
1424 {
1425 VFS_FIND(get_shadow_copy_data);
1426 return handle->fns->get_shadow_copy_data_fn(handle, fsp,
1427 shadow_copy_data,
1428 labels);
1429 }
1430 int smb_vfs_call_statvfs(struct vfs_handle_struct *handle, const char *path,
1431 struct vfs_statvfs_struct *statbuf)
1432 {
1433 VFS_FIND(statvfs);
1434 return handle->fns->statvfs_fn(handle, path, statbuf);
1435 }
1436
1437 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle,
1438 enum timestamp_set_resolution *p_ts_res)
1439 {
1440 VFS_FIND(fs_capabilities);
1441 return handle->fns->fs_capabilities_fn(handle, p_ts_res);
1442 }
1443
1444 NTSTATUS smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct *handle,
1445 struct dfs_GetDFSReferral *r)
1446 {
1447 VFS_FIND(get_dfs_referrals);
1448 return handle->fns->get_dfs_referrals_fn(handle, r);
1449 }
1450
1451 DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle,
1452 const char *fname, const char *mask,
1453 uint32 attributes)
1454 {
1455 VFS_FIND(opendir);
1456 return handle->fns->opendir_fn(handle, fname, mask, attributes);
1457 }
1458
1459 DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle,
1460 struct files_struct *fsp,
1461 const char *mask,
1462 uint32 attributes)
1463 {
1464 VFS_FIND(fdopendir);
1465 return handle->fns->fdopendir_fn(handle, fsp, mask, attributes);
1466 }
1467
1468 struct dirent *smb_vfs_call_readdir(struct vfs_handle_struct *handle,
1469 DIR *dirp,
1470 SMB_STRUCT_STAT *sbuf)
1471 {
1472 VFS_FIND(readdir);
1473 return handle->fns->readdir_fn(handle, dirp, sbuf);
1474 }
1475
1476 void smb_vfs_call_seekdir(struct vfs_handle_struct *handle,
1477 DIR *dirp, long offset)
1478 {
1479 VFS_FIND(seekdir);
1480 handle->fns->seekdir_fn(handle, dirp, offset);
1481 }
1482
1483 long smb_vfs_call_telldir(struct vfs_handle_struct *handle,
1484 DIR *dirp)
1485 {
1486 VFS_FIND(telldir);
1487 return handle->fns->telldir_fn(handle, dirp);
1488 }
1489
1490 void smb_vfs_call_rewind_dir(struct vfs_handle_struct *handle,
1491 DIR *dirp)
1492 {
1493 VFS_FIND(rewind_dir);
1494 handle->fns->rewind_dir_fn(handle, dirp);
1495 }
1496
1497 int smb_vfs_call_mkdir(struct vfs_handle_struct *handle, const char *path,
1498 mode_t mode)
1499 {
1500 VFS_FIND(mkdir);
1501 return handle->fns->mkdir_fn(handle, path, mode);
1502 }
1503
1504 int smb_vfs_call_rmdir(struct vfs_handle_struct *handle, const char *path)
1505 {
1506 VFS_FIND(rmdir);
1507 return handle->fns->rmdir_fn(handle, path);
1508 }
1509
1510 int smb_vfs_call_closedir(struct vfs_handle_struct *handle,
1511 DIR *dir)
1512 {
1513 VFS_FIND(closedir);
1514 return handle->fns->closedir_fn(handle, dir);
1515 }
1516
1517 void smb_vfs_call_init_search_op(struct vfs_handle_struct *handle,
1518 DIR *dirp)
1519 {
1520 VFS_FIND(init_search_op);
1521 handle->fns->init_search_op_fn(handle, dirp);
1522 }
1523
1524 int smb_vfs_call_open(struct vfs_handle_struct *handle,
1525 struct smb_filename *smb_fname, struct files_struct *fsp,
1526 int flags, mode_t mode)
1527 {
1528 VFS_FIND(open);
1529 return handle->fns->open_fn(handle, smb_fname, fsp, flags, mode);
1530 }
1531
1532 NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle,
1533 struct smb_request *req,
1534 uint16_t root_dir_fid,
1535 struct smb_filename *smb_fname,
1536 uint32_t access_mask,
1537 uint32_t share_access,
1538 uint32_t create_disposition,
1539 uint32_t create_options,
1540 uint32_t file_attributes,
1541 uint32_t oplock_request,
1542 struct smb2_lease *lease,
1543 uint64_t allocation_size,
1544 uint32_t private_flags,
1545 struct security_descriptor *sd,
1546 struct ea_list *ea_list,
1547 files_struct **result,
1548 int *pinfo)
1549 {
1550 VFS_FIND(create_file);
1551 return handle->fns->create_file_fn(
1552 handle, req, root_dir_fid, smb_fname, access_mask,
1553 share_access, create_disposition, create_options,
1554 file_attributes, oplock_request, lease, allocation_size,
1555 private_flags, sd, ea_list,
1556 result, pinfo);
1557 }
1558
1559 int smb_vfs_call_close(struct vfs_handle_struct *handle,
1560 struct files_struct *fsp)
1561 {
1562 VFS_FIND(close);
1563 return handle->fns->close_fn(handle, fsp);
1564 }
1565
1566 ssize_t smb_vfs_call_read(struct vfs_handle_struct *handle,
1567 struct files_struct *fsp, void *data, size_t n)
1568 {
1569 VFS_FIND(read);
1570 return handle->fns->read_fn(handle, fsp, data, n);
1571 }
1572
1573 ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
1574 struct files_struct *fsp, void *data, size_t n,
1575 off_t offset)
1576 {
1577 VFS_FIND(pread);
1578 return handle->fns->pread_fn(handle, fsp, data, n, offset);
1579 }
1580
1581 struct smb_vfs_call_pread_state {
1582 ssize_t (*recv_fn)(struct tevent_req *req, int *err);
1583 ssize_t retval;
1584 };
1585
1586 static void smb_vfs_call_pread_done(struct tevent_req *subreq);
1587
1588 struct tevent_req *smb_vfs_call_pread_send(struct vfs_handle_struct *handle,
1589 TALLOC_CTX *mem_ctx,
1590 struct tevent_context *ev,
1591 struct files_struct *fsp,
1592 void *data,
1593 size_t n, off_t offset)
1594 {
1595 struct tevent_req *req, *subreq;
1596 struct smb_vfs_call_pread_state *state;
1597
1598 req = tevent_req_create(mem_ctx, &state,
1599 struct smb_vfs_call_pread_state);
1600 if (req == NULL) {
1601 return NULL;
1602 }
1603 VFS_FIND(pread_send);
1604 state->recv_fn = handle->fns->pread_recv_fn;
1605
1606 subreq = handle->fns->pread_send_fn(handle, state, ev, fsp, data, n,
1607 offset);
1608 if (tevent_req_nomem(subreq, req)) {
1609 return tevent_req_post(req, ev);
1610 }
1611 tevent_req_set_callback(subreq, smb_vfs_call_pread_done, req);
1612 return req;
1613 }
1614
1615 static void smb_vfs_call_pread_done(struct tevent_req *subreq)
1616 {
1617 struct tevent_req *req = tevent_req_callback_data(
1618 subreq, struct tevent_req);
1619 struct smb_vfs_call_pread_state *state = tevent_req_data(
1620 req, struct smb_vfs_call_pread_state);
1621 int err;
1622
1623 state->retval = state->recv_fn(subreq, &err);
1624 TALLOC_FREE(subreq);
1625 if (state->retval == -1) {
1626 tevent_req_error(req, err);
1627 return;
1628 }
1629 tevent_req_done(req);
1630 }
1631
1632 ssize_t SMB_VFS_PREAD_RECV(struct tevent_req *req, int *perrno)
1633 {
1634 struct smb_vfs_call_pread_state *state = tevent_req_data(
1635 req, struct smb_vfs_call_pread_state);
1636 int err;
1637
1638 if (tevent_req_is_unix_error(req, &err)) {
1639 *perrno = err;
1640 return -1;
1641 }
1642 return state->retval;
1643 }
1644
1645 ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle,
1646 struct files_struct *fsp, const void *data,
1647 size_t n)
1648 {
1649 VFS_FIND(write);
1650 return handle->fns->write_fn(handle, fsp, data, n);
1651 }
1652
1653 ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
1654 struct files_struct *fsp, const void *data,
1655 size_t n, off_t offset)
1656 {
1657 VFS_FIND(pwrite);
1658 return handle->fns->pwrite_fn(handle, fsp, data, n, offset);
1659 }
1660
1661 struct smb_vfs_call_pwrite_state {
1662 ssize_t (*recv_fn)(struct tevent_req *req, int *err);
1663 ssize_t retval;
1664 };
1665
1666 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq);
1667
1668 struct tevent_req *smb_vfs_call_pwrite_send(struct vfs_handle_struct *handle,
1669 TALLOC_CTX *mem_ctx,
1670 struct tevent_context *ev,
1671 struct files_struct *fsp,
1672 const void *data,
1673 size_t n, off_t offset)
1674 {
1675 struct tevent_req *req, *subreq;
1676 struct smb_vfs_call_pwrite_state *state;
1677
1678 req = tevent_req_create(mem_ctx, &state,
1679 struct smb_vfs_call_pwrite_state);
1680 if (req == NULL) {
1681 return NULL;
1682 }
1683 VFS_FIND(pwrite_send);
1684 state->recv_fn = handle->fns->pwrite_recv_fn;
1685
1686 subreq = handle->fns->pwrite_send_fn(handle, state, ev, fsp, data, n,
1687 offset);
1688 if (tevent_req_nomem(subreq, req)) {
1689 return tevent_req_post(req, ev);
1690 }
1691 tevent_req_set_callback(subreq, smb_vfs_call_pwrite_done, req);
1692 return req;
1693 }
1694
1695 static void smb_vfs_call_pwrite_done(struct tevent_req *subreq)
1696 {
1697 struct tevent_req *req = tevent_req_callback_data(
1698 subreq, struct tevent_req);
1699 struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1700 req, struct smb_vfs_call_pwrite_state);
1701 int err;
1702
1703 state->retval = state->recv_fn(subreq, &err);
1704 TALLOC_FREE(subreq);
1705 if (state->retval == -1) {
1706 tevent_req_error(req, err);
1707 return;
1708 }
1709 tevent_req_done(req);
1710 }
1711
1712 ssize_t SMB_VFS_PWRITE_RECV(struct tevent_req *req, int *perrno)
1713 {
1714 struct smb_vfs_call_pwrite_state *state = tevent_req_data(
1715 req, struct smb_vfs_call_pwrite_state);
1716 int err;
1717
1718 if (tevent_req_is_unix_error(req, &err)) {
1719 *perrno = err;
1720 return -1;
1721 }
1722 return state->retval;
1723 }
1724
1725 off_t smb_vfs_call_lseek(struct vfs_handle_struct *handle,
1726 struct files_struct *fsp, off_t offset,
1727 int whence)
1728 {
1729 VFS_FIND(lseek);
1730 return handle->fns->lseek_fn(handle, fsp, offset, whence);
1731 }
1732
1733 ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
1734 files_struct *fromfsp, const DATA_BLOB *header,
1735 off_t offset, size_t count)
1736 {
1737 VFS_FIND(sendfile);
1738 return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset,
1739 count);
1740 }
1741
1742 ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
1743 files_struct *tofsp, off_t offset,
1744 size_t count)
1745 {
1746 VFS_FIND(recvfile);
1747 return handle->fns->recvfile_fn(handle, fromfd, tofsp, offset, count);
1748 }
1749
1750 int smb_vfs_call_rename(struct vfs_handle_struct *handle,
1751 const struct smb_filename *smb_fname_src,
1752 const struct smb_filename *smb_fname_dst)
1753 {
1754 VFS_FIND(rename);
1755 return handle->fns->rename_fn(handle, smb_fname_src, smb_fname_dst);
1756 }
1757
1758 int smb_vfs_call_fsync(struct vfs_handle_struct *handle,
1759 struct files_struct *fsp)
1760 {
1761 VFS_FIND(fsync);
1762 return handle->fns->fsync_fn(handle, fsp);
1763 }
1764
1765 struct smb_vfs_call_fsync_state {
1766 int (*recv_fn)(struct tevent_req *req, int *err);
1767 int retval;
1768 };
1769
1770 static void smb_vfs_call_fsync_done(struct tevent_req *subreq);
1771
1772 struct tevent_req *smb_vfs_call_fsync_send(struct vfs_handle_struct *handle,
1773 TALLOC_CTX *mem_ctx,
1774 struct tevent_context *ev,
1775 struct files_struct *fsp)
1776 {
1777 struct tevent_req *req, *subreq;
1778 struct smb_vfs_call_fsync_state *state;
1779
1780 req = tevent_req_create(mem_ctx, &state,
1781 struct smb_vfs_call_fsync_state);
1782 if (req == NULL) {
1783 return NULL;
1784 }
1785 VFS_FIND(fsync_send);
1786 state->recv_fn = handle->fns->fsync_recv_fn;
1787
1788 subreq = handle->fns->fsync_send_fn(handle, state, ev, fsp);
1789 if (tevent_req_nomem(subreq, req)) {
1790 return tevent_req_post(req, ev);
1791 }
1792 tevent_req_set_callback(subreq, smb_vfs_call_fsync_done, req);
1793 return req;
1794 }
1795
1796 static void smb_vfs_call_fsync_done(struct tevent_req *subreq)
1797 {
1798 struct tevent_req *req = tevent_req_callback_data(
1799 subreq, struct tevent_req);
1800 struct smb_vfs_call_fsync_state *state = tevent_req_data(
1801 req, struct smb_vfs_call_fsync_state);
1802 int err;
1803
1804 state->retval = state->recv_fn(subreq, &err);
1805 TALLOC_FREE(subreq);
1806 if (state->retval == -1) {
1807 tevent_req_error(req, err);
1808 return;
1809 }
1810 tevent_req_done(req);
1811 }
1812
1813 int SMB_VFS_FSYNC_RECV(struct tevent_req *req, int *perrno)
1814 {
1815 struct smb_vfs_call_fsync_state *state = tevent_req_data(
1816 req, struct smb_vfs_call_fsync_state);
1817 int err;
1818
1819 if (tevent_req_is_unix_error(req, &err)) {
1820 *perrno = err;
1821 return -1;
1822 }
1823 return state->retval;
1824 }
1825
1826
1827 int smb_vfs_call_stat(struct vfs_handle_struct *handle,
1828 struct smb_filename *smb_fname)
1829 {
1830 VFS_FIND(stat);
1831 return handle->fns->stat_fn(handle, smb_fname);
1832 }
1833
1834 int smb_vfs_call_fstat(struct vfs_handle_struct *handle,
1835 struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1836 {
1837 VFS_FIND(fstat);
1838 return handle->fns->fstat_fn(handle, fsp, sbuf);
1839 }
1840
1841 int smb_vfs_call_lstat(struct vfs_handle_struct *handle,
1842 struct smb_filename *smb_filename)
1843 {
1844 VFS_FIND(lstat);
1845 return handle->fns->lstat_fn(handle, smb_filename);
1846 }
1847
1848 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle,
1849 struct files_struct *fsp,
1850 const SMB_STRUCT_STAT *sbuf)
1851 {
1852 VFS_FIND(get_alloc_size);
1853 return handle->fns->get_alloc_size_fn(handle, fsp, sbuf);
1854 }
1855
1856 int smb_vfs_call_unlink(struct vfs_handle_struct *handle,
1857 const struct smb_filename *smb_fname)
1858 {
1859 VFS_FIND(unlink);
1860 return handle->fns->unlink_fn(handle, smb_fname);
1861 }
1862
1863 int smb_vfs_call_chmod(struct vfs_handle_struct *handle, const char *path,
1864 mode_t mode)
1865 {
1866 VFS_FIND(chmod);
1867 return handle->fns->chmod_fn(handle, path, mode);
1868 }
1869
1870 int smb_vfs_call_fchmod(struct vfs_handle_struct *handle,
1871 struct files_struct *fsp, mode_t mode)
1872 {
1873 VFS_FIND(fchmod);
1874 return handle->fns->fchmod_fn(handle, fsp, mode);
1875 }
1876
1877 int smb_vfs_call_chown(struct vfs_handle_struct *handle, const char *path,
1878 uid_t uid, gid_t gid)
1879 {
1880 VFS_FIND(chown);
1881 return handle->fns->chown_fn(handle, path, uid, gid);
1882 }
1883
1884 int smb_vfs_call_fchown(struct vfs_handle_struct *handle,
1885 struct files_struct *fsp, uid_t uid, gid_t gid)
1886 {
1887 VFS_FIND(fchown);
1888 return handle->fns->fchown_fn(handle, fsp, uid, gid);
1889 }
1890
1891 int smb_vfs_call_lchown(struct vfs_handle_struct *handle, const char *path,
1892 uid_t uid, gid_t gid)
1893 {
1894 VFS_FIND(lchown);
1895 return handle->fns->lchown_fn(handle, path, uid, gid);
1896 }
1897
1898 NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid)
1899 {
1900 int ret;
1901 bool as_root = false;
1902 const char *path;
1903 char *saved_dir = NULL;
1904 char *parent_dir = NULL;
1905 NTSTATUS status;
1906
1907 if (fsp->fh->fd != -1) {
1908 /* Try fchown. */
1909 ret = SMB_VFS_FCHOWN(fsp, uid, gid);
1910 if (ret == 0) {
1911 return NT_STATUS_OK;
1912 }
1913 if (ret == -1 && errno != ENOSYS) {
1914 return map_nt_error_from_unix(errno);
1915 }
1916 }
1917
1918 as_root = (geteuid() == 0);
1919
1920 if (as_root) {
1921 /*
1922 * We are being asked to chown as root. Make
1923 * sure we chdir() into the path to pin it,
1924 * and always act using lchown to ensure we
1925 * don't deref any symbolic links.
1926 */
1927 const char *final_component = NULL;
1928 struct smb_filename local_fname;
1929
1930 saved_dir = vfs_GetWd(talloc_tos(),fsp->conn);
1931 if (!saved_dir) {
1932 status = map_nt_error_from_unix(errno);
1933 DEBUG(0,("vfs_chown_fsp: failed to get "
1934 "current working directory. Error was %s\n",
1935 strerror(errno)));
1936 return status;
1937 }
1938
1939 if (!parent_dirname(talloc_tos(),
1940 fsp->fsp_name->base_name,
1941 &parent_dir,
1942 &final_component)) {
1943 return NT_STATUS_NO_MEMORY;
1944 }
1945
1946 /* cd into the parent dir to pin it. */
1947 ret = vfs_ChDir(fsp->conn, parent_dir);
1948 if (ret == -1) {
1949 return map_nt_error_from_unix(errno);
1950 }
1951
1952 ZERO_STRUCT(local_fname);
1953 local_fname.base_name = discard_const_p(char, final_component);
1954
1955 /* Must use lstat here. */
1956 ret = SMB_VFS_LSTAT(fsp->conn, &local_fname);
1957 if (ret == -1) {
1958 status = map_nt_error_from_unix(errno);
1959 goto out;
1960 }
1961
1962 /* Ensure it matches the fsp stat. */
1963 if (!check_same_stat(&local_fname.st, &fsp->fsp_name->st)) {
1964 status = NT_STATUS_ACCESS_DENIED;
1965 goto out;
1966 }
1967 path = final_component;
1968 } else {
1969 path = fsp->fsp_name->base_name;
1970 }
1971
1972 if (fsp->posix_open || as_root) {
1973 ret = SMB_VFS_LCHOWN(fsp->conn,
1974 path,
1975 uid, gid);
1976 } else {
1977 ret = SMB_VFS_CHOWN(fsp->conn,
1978 path,
1979 uid, gid);
1980 }
1981
1982 if (ret == 0) {
1983 status = NT_STATUS_OK;
1984 } else {
1985 status = map_nt_error_from_unix(errno);
1986 }
1987
1988 out:
1989
1990 if (as_root) {
1991 vfs_ChDir(fsp->conn,saved_dir);
1992 TALLOC_FREE(saved_dir);
1993 TALLOC_FREE(parent_dir);
1994 }
1995 return status;
1996 }
1997
1998 int smb_vfs_call_chdir(struct vfs_handle_struct *handle, const char *path)
1999 {
2000 VFS_FIND(chdir);
2001 return handle->fns->chdir_fn(handle, path);
2002 }
2003
2004 char *smb_vfs_call_getwd(struct vfs_handle_struct *handle)
2005 {
2006 VFS_FIND(getwd);
2007 return handle->fns->getwd_fn(handle);
2008 }
2009
2010 int smb_vfs_call_ntimes(struct vfs_handle_struct *handle,
2011 const struct smb_filename *smb_fname,
2012 struct smb_file_time *ft)
2013 {
2014 VFS_FIND(ntimes);
2015 return handle->fns->ntimes_fn(handle, smb_fname, ft);
2016 }
2017
2018 int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
2019 struct files_struct *fsp, off_t offset)
2020 {
2021 VFS_FIND(ftruncate);
2022 return handle->fns->ftruncate_fn(handle, fsp, offset);
2023 }
2024
2025 int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
2026 struct files_struct *fsp,
2027 enum vfs_fallocate_mode mode,
2028 off_t offset,
2029 off_t len)
2030 {
2031 VFS_FIND(fallocate);
2032 return handle->fns->fallocate_fn(handle, fsp, mode, offset, len);
2033 }
2034
2035 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
2036 struct files_struct *fsp, uint32 share_mode,
2037 uint32_t access_mask)
2038 {
2039 VFS_FIND(kernel_flock);
2040 return handle->fns->kernel_flock_fn(handle, fsp, share_mode,
2041 access_mask);
2042 }
2043
2044 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
2045 struct files_struct *fsp, int leasetype)
2046 {
2047 VFS_FIND(linux_setlease);
2048 return handle->fns->linux_setlease_fn(handle, fsp, leasetype);
2049 }
2050
2051 int smb_vfs_call_symlink(struct vfs_handle_struct *handle, const char *oldpath,
2052 const char *newpath)
2053 {
2054 VFS_FIND(symlink);
2055 return handle->fns->symlink_fn(handle, oldpath, newpath);
2056 }
2057
2058 int smb_vfs_call_readlink(struct vfs_handle_struct *handle,
2059 const char *path, char *buf, size_t bufsiz)
2060 {
2061 VFS_FIND(readlink);
2062 return handle->fns->readlink_fn(handle, path, buf, bufsiz);
2063 }
2064
2065 int smb_vfs_call_link(struct vfs_handle_struct *handle, const char *oldpath,
2066 const char *newpath)
2067 {
2068 VFS_FIND(link);
2069 return handle->fns->link_fn(handle, oldpath, newpath);
2070 }
2071
2072 int smb_vfs_call_mknod(struct vfs_handle_struct *handle, const char *path,
2073 mode_t mode, SMB_DEV_T dev)
2074 {
2075 VFS_FIND(mknod);
2076 return handle->fns->mknod_fn(handle, path, mode, dev);
2077 }
2078
2079 char *smb_vfs_call_realpath(struct vfs_handle_struct *handle, const char *path)
2080 {
2081 VFS_FIND(realpath);
2082 return handle->fns->realpath_fn(handle, path);
2083 }
2084
2085 NTSTATUS smb_vfs_call_notify_watch(struct vfs_handle_struct *handle,
2086 struct sys_notify_context *ctx,
2087 const char *path,
2088 uint32_t *filter,
2089 uint32_t *subdir_filter,
2090 void (*callback)(struct sys_notify_context *ctx,
2091 void *private_data,
2092 struct notify_event *ev),
2093 void *private_data, void *handle_p)
2094 {
2095 VFS_FIND(notify_watch);
2096 return handle->fns->notify_watch_fn(handle, ctx, path,
2097 filter, subdir_filter, callback,
2098 private_data, handle_p);
2099 }
2100
2101 int smb_vfs_call_chflags(struct vfs_handle_struct *handle, const char *path,
2102 unsigned int flags)
2103 {
2104 VFS_FIND(chflags);
2105 return handle->fns->chflags_fn(handle, path, flags);
2106 }
2107
2108 struct file_id smb_vfs_call_file_id_create(struct vfs_handle_struct *handle,
2109 const SMB_STRUCT_STAT *sbuf)
2110 {
2111 VFS_FIND(file_id_create);
2112 return handle->fns->file_id_create_fn(handle, sbuf);
2113 }
2114
2115 NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle,
2116 struct files_struct *fsp,
2117 const char *fname,
2118 TALLOC_CTX *mem_ctx,
2119 unsigned int *num_streams,
2120 struct stream_struct **streams)
2121 {
2122 VFS_FIND(streaminfo);
2123 return handle->fns->streaminfo_fn(handle, fsp, fname, mem_ctx,
2124 num_streams, streams);
2125 }
2126
2127 int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle,
2128 const char *path, const char *name,
2129 TALLOC_CTX *mem_ctx, char **found_name)
2130 {
2131 VFS_FIND(get_real_filename);
2132 return handle->fns->get_real_filename_fn(handle, path, name, mem_ctx,
2133 found_name);
2134 }
2135
2136 const char *smb_vfs_call_connectpath(struct vfs_handle_struct *handle,
2137 const char *filename)
2138 {
2139 VFS_FIND(connectpath);
2140 return handle->fns->connectpath_fn(handle, filename);
2141 }
2142
2143 bool smb_vfs_call_strict_lock(struct vfs_handle_struct *handle,
2144 struct files_struct *fsp,
2145 struct lock_struct *plock)
2146 {
2147 VFS_FIND(strict_lock);
2148 return handle->fns->strict_lock_fn(handle, fsp, plock);
2149 }
2150
2151 void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle,
2152 struct files_struct *fsp,
2153 struct lock_struct *plock)
2154 {
2155 VFS_FIND(strict_unlock);
2156 handle->fns->strict_unlock_fn(handle, fsp, plock);
2157 }
2158
2159 NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
2160 const char *name,
2161 enum vfs_translate_direction direction,
2162 TALLOC_CTX *mem_ctx,
2163 char **mapped_name)
2164 {
2165 VFS_FIND(translate_name);
2166 return handle->fns->translate_name_fn(handle, name, direction, mem_ctx,
2167 mapped_name);
2168 }
2169
2170 NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle,
2171 struct files_struct *fsp,
2172 TALLOC_CTX *ctx,
2173 uint32_t function,
2174 uint16_t req_flags,
2175 const uint8_t *in_data,
2176 uint32_t in_len,
2177 uint8_t **out_data,
2178 uint32_t max_out_len,
2179 uint32_t *out_len)
2180 {
2181 VFS_FIND(fsctl);
2182 return handle->fns->fsctl_fn(handle, fsp, ctx, function, req_flags,
2183 in_data, in_len, out_data, max_out_len,
2184 out_len);
2185 }
2186
2187 struct tevent_req *smb_vfs_call_copy_chunk_send(struct vfs_handle_struct *handle,
2188 TALLOC_CTX *mem_ctx,
2189 struct tevent_context *ev,
2190 struct files_struct *src_fsp,
2191 off_t src_off,
2192 struct files_struct *dest_fsp,
2193 off_t dest_off,
2194 off_t num)
2195 {
2196 VFS_FIND(copy_chunk_send);
2197 return handle->fns->copy_chunk_send_fn(handle, mem_ctx, ev, src_fsp,
2198 src_off, dest_fsp, dest_off, num);
2199 }
2200
2201 NTSTATUS smb_vfs_call_copy_chunk_recv(struct vfs_handle_struct *handle,
2202 struct tevent_req *req,
2203 off_t *copied)
2204 {
2205 VFS_FIND(copy_chunk_recv);
2206 return handle->fns->copy_chunk_recv_fn(handle, req, copied);
2207 }
2208
2209 NTSTATUS smb_vfs_call_get_compression(vfs_handle_struct *handle,
2210 TALLOC_CTX *mem_ctx,
2211 struct files_struct *fsp,
2212 struct smb_filename *smb_fname,
2213 uint16_t *_compression_fmt)
2214 {
2215 VFS_FIND(get_compression);
2216 return handle->fns->get_compression_fn(handle, mem_ctx, fsp, smb_fname,
2217 _compression_fmt);
2218 }
2219
2220 NTSTATUS smb_vfs_call_set_compression(vfs_handle_struct *handle,
2221 TALLOC_CTX *mem_ctx,
2222 struct files_struct *fsp,
2223 uint16_t compression_fmt)
2224 {
2225 VFS_FIND(set_compression);
2226 return handle->fns->set_compression_fn(handle, mem_ctx, fsp,
2227 compression_fmt);
2228 }
2229
2230 NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle,
2231 struct files_struct *fsp,
2232 uint32 security_info,
2233 TALLOC_CTX *mem_ctx,
2234 struct security_descriptor **ppdesc)
2235 {
2236 VFS_FIND(fget_nt_acl);
2237 return handle->fns->fget_nt_acl_fn(handle, fsp, security_info,
2238 mem_ctx, ppdesc);
2239 }
2240
2241 NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle,
2242 const char *name,
2243 uint32 security_info,
2244 TALLOC_CTX *mem_ctx,
2245 struct security_descriptor **ppdesc)
2246 {
2247 VFS_FIND(get_nt_acl);
2248 return handle->fns->get_nt_acl_fn(handle, name, security_info, mem_ctx, ppdesc);
2249 }
2250
2251 NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle,
2252 struct files_struct *fsp,
2253 uint32 security_info_sent,
2254 const struct security_descriptor *psd)
2255 {
2256 VFS_FIND(fset_nt_acl);
2257 return handle->fns->fset_nt_acl_fn(handle, fsp, security_info_sent,
2258 psd);
2259 }
2260
2261 NTSTATUS smb_vfs_call_audit_file(struct vfs_handle_struct *handle,
2262 struct smb_filename *file,
2263 struct security_acl *sacl,
2264 uint32_t access_requested,
2265 uint32_t access_denied)
2266 {
2267 VFS_FIND(audit_file);
2268 return handle->fns->audit_file_fn(handle,
2269 file,
2270 sacl,
2271 access_requested,
2272 access_denied);
2273 }
2274
2275 int smb_vfs_call_chmod_acl(struct vfs_handle_struct *handle, const char *name,
2276 mode_t mode)
2277 {
2278 VFS_FIND(chmod_acl);
2279 return handle->fns->chmod_acl_fn(handle, name, mode);
2280 }
2281
2282 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct *handle,
2283 struct files_struct *fsp, mode_t mode)
2284 {
2285 VFS_FIND(fchmod_acl);
2286 return handle->fns->fchmod_acl_fn(handle, fsp, mode);
2287 }
2288
2289 SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle,
2290 const char *path_p,
2291 SMB_ACL_TYPE_T type,
2292 TALLOC_CTX *mem_ctx)
2293 {
2294 VFS_FIND(sys_acl_get_file);
2295 return handle->fns->sys_acl_get_file_fn(handle, path_p, type, mem_ctx);
2296 }
2297
2298 SMB_ACL_T smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct *handle,
2299 struct files_struct *fsp,
2300 TALLOC_CTX *mem_ctx)
2301 {
2302 VFS_FIND(sys_acl_get_fd);
2303 return handle->fns->sys_acl_get_fd_fn(handle, fsp, mem_ctx);
2304 }
2305
2306 int smb_vfs_call_sys_acl_blob_get_file(struct vfs_handle_struct *handle,
2307 const char *path_p,
2308 TALLOC_CTX *mem_ctx,
2309 char **blob_description,
2310 DATA_BLOB *blob)
2311 {
2312 VFS_FIND(sys_acl_blob_get_file);
2313 return handle->fns->sys_acl_blob_get_file_fn(handle, path_p, mem_ctx, blob_description, blob);
2314 }
2315
2316 int smb_vfs_call_sys_acl_blob_get_fd(struct vfs_handle_struct *handle,
2317 struct files_struct *fsp,
2318 TALLOC_CTX *mem_ctx,
2319 char **blob_description,
2320 DATA_BLOB *blob)
2321 {
2322 VFS_FIND(sys_acl_blob_get_fd);
2323 return handle->fns->sys_acl_blob_get_fd_fn(handle, fsp, mem_ctx, blob_description, blob);
2324 }
2325
2326 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle,
2327 const char *name, SMB_ACL_TYPE_T acltype,
2328 SMB_ACL_T theacl)
2329 {
2330 VFS_FIND(sys_acl_set_file);
2331 return handle->fns->sys_acl_set_file_fn(handle, name, acltype, theacl);
2332 }
2333
2334 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct *handle,
2335 struct files_struct *fsp, SMB_ACL_T theacl)
2336 {
2337 VFS_FIND(sys_acl_set_fd);
2338 return handle->fns->sys_acl_set_fd_fn(handle, fsp, theacl);
2339 }
2340
2341 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct *handle,
2342 const char *path)
2343 {
2344 VFS_FIND(sys_acl_delete_def_file);
2345 return handle->fns->sys_acl_delete_def_file_fn(handle, path);
2346 }
2347
2348 ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle,
2349 const char *path, const char *name, void *value,
2350 size_t size)
2351 {
2352 VFS_FIND(getxattr);
2353 return handle->fns->getxattr_fn(handle, path, name, value, size);
2354 }
2355
2356 ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle,
2357 struct files_struct *fsp, const char *name,
2358 void *value, size_t size)
2359 {
2360 VFS_FIND(fgetxattr);
2361 return handle->fns->fgetxattr_fn(handle, fsp, name, value, size);
2362 }
2363
2364 ssize_t smb_vfs_call_listxattr(struct vfs_handle_struct *handle,
2365 const char *path, char *list, size_t size)
2366 {
2367 VFS_FIND(listxattr);
2368 return handle->fns->listxattr_fn(handle, path, list, size);
2369 }
2370
2371 ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle,
2372 struct files_struct *fsp, char *list,
2373 size_t size)
2374 {
2375 VFS_FIND(flistxattr);
2376 return handle->fns->flistxattr_fn(handle, fsp, list, size);
2377 }
2378
2379 int smb_vfs_call_removexattr(struct vfs_handle_struct *handle,
2380 const char *path, const char *name)
2381 {
2382 VFS_FIND(removexattr);
2383 return handle->fns->removexattr_fn(handle, path, name);
2384 }
2385
2386 int smb_vfs_call_fremovexattr(struct vfs_handle_struct *handle,
2387 struct files_struct *fsp, const char *name)
2388 {
2389 VFS_FIND(fremovexattr);
2390 return handle->fns->fremovexattr_fn(handle, fsp, name);
2391 }
2392
2393 int smb_vfs_call_setxattr(struct vfs_handle_struct *handle, const char *path,
2394 const char *name, const void *value, size_t size,
2395 int flags)
2396 {
2397 VFS_FIND(setxattr);
2398 return handle->fns->setxattr_fn(handle, path, name, value, size, flags);
2399 }
2400
2401 int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle,
2402 struct files_struct *fsp, const char *name,
2403 const void *value, size_t size, int flags)
2404 {
2405 VFS_FIND(fsetxattr);
2406 return handle->fns->fsetxattr_fn(handle, fsp, name, value, size, flags);
2407 }
2408
2409 bool smb_vfs_call_aio_force(struct vfs_handle_struct *handle,
2410 struct files_struct *fsp)
2411 {
2412 VFS_FIND(aio_force);
2413 return handle->fns->aio_force_fn(handle, fsp);
2414 }
2415
2416 bool smb_vfs_call_is_offline(struct vfs_handle_struct *handle,
2417 const struct smb_filename *fname,
2418 SMB_STRUCT_STAT *sbuf)
2419 {
2420 VFS_FIND(is_offline);
2421 return handle->fns->is_offline_fn(handle, fname, sbuf);
2422 }
2423
2424 int smb_vfs_call_set_offline(struct vfs_handle_struct *handle,
2425 const struct smb_filename *fname)
2426 {
2427 VFS_FIND(set_offline);
2428 return handle->fns->set_offline_fn(handle, fname);
2429 }
2430
2431 NTSTATUS smb_vfs_call_durable_cookie(struct vfs_handle_struct *handle,
2432 struct files_struct *fsp,
2433 TALLOC_CTX *mem_ctx,
2434 DATA_BLOB *cookie)
2435 {
2436 VFS_FIND(durable_cookie);
2437 return handle->fns->durable_cookie_fn(handle, fsp, mem_ctx, cookie);
2438 }
2439
2440 NTSTATUS smb_vfs_call_durable_disconnect(struct vfs_handle_struct *handle,
2441 struct files_struct *fsp,
2442 const DATA_BLOB old_cookie,
2443 TALLOC_CTX *mem_ctx,
2444 DATA_BLOB *new_cookie)
2445 {
2446 VFS_FIND(durable_disconnect);
2447 return handle->fns->durable_disconnect_fn(handle, fsp, old_cookie,
2448 mem_ctx, new_cookie);
2449 }
2450
2451 NTSTATUS smb_vfs_call_durable_reconnect(struct vfs_handle_struct *handle,
2452 struct smb_request *smb1req,
2453 struct smbXsrv_open *op,
2454 const DATA_BLOB old_cookie,
2455 TALLOC_CTX *mem_ctx,
2456 struct files_struct **fsp,
2457 DATA_BLOB *new_cookie)
2458 {
2459 VFS_FIND(durable_reconnect);
2460 return handle->fns->durable_reconnect_fn(handle, smb1req, op,
2461 old_cookie, mem_ctx, fsp,
2462 new_cookie);
2463 }
2464
2465 NTSTATUS smb_vfs_call_readdir_attr(struct vfs_handle_struct *handle,
2466 const struct smb_filename *fname,
2467 TALLOC_CTX *mem_ctx,
2468 struct readdir_attr_data **attr_data)
2469 {
2470 VFS_FIND(readdir_attr);
2471 return handle->fns->readdir_attr_fn(handle, fname, mem_ctx, attr_data);
2472 }
Samba GIT mirror