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