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