?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: Pass "path" through vfs_notify_watch
[Samba/gebeck_regimport.git] / source3 / smbd / vfs.c
blob6b7b8691aaedfa6497dc5a484ebcbc9a23443935
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_probe_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, SMB_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 (SMB_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 SMB_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 (((SMB_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, (SMB_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, SMB_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, SMB_OFF_T offset, SMB_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, SMB_OFF_T len)
623 {
624 int ret;
625 NTSTATUS status;
626 SMB_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 SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_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 SMB_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, (SMB_STRUCT_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
1093 /* Last component didn't exist.
1094 Remove it and try and canonicalise
1095 the directory name. */
1096 if (!parent_dirname(ctx, fname,
1097 &dir_name,
1098 &last_component)) {
1099 return NT_STATUS_NO_MEMORY;
1100 }
1101
1102 resolved_name = SMB_VFS_REALPATH(conn,dir_name);
1103 if (!resolved_name) {
1104 NTSTATUS status = map_nt_error_from_unix(errno);
1105
1106 if (errno == ENOENT || errno == ENOTDIR) {
1107 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
1108 }
1109
1110 DEBUG(3,("check_reduce_name: "
1111 "couldn't get realpath for "
1112 "%s (%s)\n",
1113 fname,
1114 nt_errstr(status)));
1115 return status;
1116 }
1117 new_name = talloc_asprintf(ctx,
1118 "%s/%s",
1119 resolved_name,
1120 last_component);
1121 if (!new_name) {
1122 return NT_STATUS_NO_MEMORY;
1123 }
1124 SAFE_FREE(resolved_name);
1125 resolved_name = SMB_STRDUP(new_name);
1126 if (!resolved_name) {
1127 return NT_STATUS_NO_MEMORY;
1128 }
1129 break;
1130 }
1131 default:
1132 DEBUG(3,("check_reduced_name: couldn't get "
1133 "realpath for %s\n", fname));
1134 return map_nt_error_from_unix(errno);
1135 }
1136 }
1137
1138 DEBUG(10,("check_reduced_name realpath [%s] -> [%s]\n", fname,
1139 resolved_name));
1140
1141 if (*resolved_name != '/') {
1142 DEBUG(0,("check_reduced_name: realpath doesn't return "
1143 "absolute paths !\n"));
1144 SAFE_FREE(resolved_name);
1145 return NT_STATUS_OBJECT_NAME_INVALID;
1146 }
1147
1148 allow_widelinks = lp_widelinks(SNUM(conn));
1149 allow_symlinks = lp_symlinks(SNUM(conn));
1150
1151 /* Common widelinks and symlinks checks. */
1152 if (!allow_widelinks || !allow_symlinks) {
1153 const char *conn_rootdir;
1154 size_t rootdir_len;
1155
1156 conn_rootdir = SMB_VFS_CONNECTPATH(conn, fname);
1157 if (conn_rootdir == NULL) {
1158 DEBUG(2, ("check_reduced_name: Could not get "
1159 "conn_rootdir\n"));
1160 SAFE_FREE(resolved_name);
1161 return NT_STATUS_ACCESS_DENIED;
1162 }
1163
1164 rootdir_len = strlen(conn_rootdir);
1165 if (strncmp(conn_rootdir, resolved_name,
1166 rootdir_len) != 0) {
1167 DEBUG(2, ("check_reduced_name: Bad access "
1168 "attempt: %s is a symlink outside the "
1169 "share path\n", fname));
1170 DEBUGADD(2, ("conn_rootdir =%s\n", conn_rootdir));
1171 DEBUGADD(2, ("resolved_name=%s\n", resolved_name));
1172 SAFE_FREE(resolved_name);
1173 return NT_STATUS_ACCESS_DENIED;
1174 }
1175
1176 /* Extra checks if all symlinks are disallowed. */
1177 if (!allow_symlinks) {
1178 /* fname can't have changed in resolved_path. */
1179 const char *p = &resolved_name[rootdir_len];
1180
1181 /* *p can be '\0' if fname was "." */
1182 if (*p == '\0' && ISDOT(fname)) {
1183 goto out;
1184 }
1185
1186 if (*p != '/') {
1187 DEBUG(2, ("check_reduced_name: logic error (%c) "
1188 "in resolved_name: %s\n",
1189 *p,
1190 fname));
1191 SAFE_FREE(resolved_name);
1192 return NT_STATUS_ACCESS_DENIED;
1193 }
1194
1195 p++;
1196 if (strcmp(fname, p)!=0) {
1197 DEBUG(2, ("check_reduced_name: Bad access "
1198 "attempt: %s is a symlink\n",
1199 fname));
1200 SAFE_FREE(resolved_name);
1201 return NT_STATUS_ACCESS_DENIED;
1202 }
1203 }
1204 }
1205
1206 out:
1207
1208 DEBUG(3,("check_reduced_name: %s reduced to %s\n", fname,
1209 resolved_name));
1210 SAFE_FREE(resolved_name);
1211 return NT_STATUS_OK;
1212 }
1213
1214 /**
1215 * XXX: This is temporary and there should be no callers of this once
1216 * smb_filename is plumbed through all path based operations.
1217 */
1218 int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
1219 SMB_STRUCT_STAT *psbuf)
1220 {
1221 struct smb_filename *smb_fname = NULL;
1222 NTSTATUS status;
1223 int ret;
1224
1225 status = create_synthetic_smb_fname_split(talloc_tos(), fname, NULL,
1226 &smb_fname);
1227 if (!NT_STATUS_IS_OK(status)) {
1228 errno = map_errno_from_nt_status(status);
1229 return -1;
1230 }
1231
1232 if (lp_posix_pathnames()) {
1233 ret = SMB_VFS_LSTAT(conn, smb_fname);
1234 } else {
1235 ret = SMB_VFS_STAT(conn, smb_fname);
1236 }
1237
1238 if (ret != -1) {
1239 *psbuf = smb_fname->st;
1240 }
1241
1242 TALLOC_FREE(smb_fname);
1243 return ret;
1244 }
1245
1246 /**
1247 * XXX: This is temporary and there should be no callers of this once
1248 * smb_filename is plumbed through all path based operations.
1249 */
1250 int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
1251 SMB_STRUCT_STAT *psbuf)
1252 {
1253 struct smb_filename *smb_fname = NULL;
1254 NTSTATUS status;
1255 int ret;
1256
1257 status = create_synthetic_smb_fname_split(talloc_tos(), fname, NULL,
1258 &smb_fname);
1259 if (!NT_STATUS_IS_OK(status)) {
1260 errno = map_errno_from_nt_status(status);
1261 return -1;
1262 }
1263
1264 ret = SMB_VFS_LSTAT(conn, smb_fname);
1265 if (ret != -1) {
1266 *psbuf = smb_fname->st;
1267 }
1268
1269 TALLOC_FREE(smb_fname);
1270 return ret;
1271 }
1272
1273 /**
1274 * Ensure LSTAT is called for POSIX paths.
1275 */
1276
1277 NTSTATUS vfs_stat_fsp(files_struct *fsp)
1278 {
1279 int ret;
1280
1281 if(fsp->fh->fd == -1) {
1282 if (fsp->posix_open) {
1283 ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
1284 } else {
1285 ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
1286 }
1287 if (ret == -1) {
1288 return map_nt_error_from_unix(errno);
1289 }
1290 } else {
1291 if(SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st) != 0) {
1292 return map_nt_error_from_unix(errno);
1293 }
1294 }
1295 return NT_STATUS_OK;
1296 }
1297
1298 /**
1299 * Initialize num_streams and streams, then call VFS op streaminfo
1300 */
1301 NTSTATUS vfs_streaminfo(connection_struct *conn,
1302 struct files_struct *fsp,
1303 const char *fname,
1304 TALLOC_CTX *mem_ctx,
1305 unsigned int *num_streams,
1306 struct stream_struct **streams)
1307 {
1308 *num_streams = 0;
1309 *streams = NULL;
1310 return SMB_VFS_STREAMINFO(conn, fsp, fname, mem_ctx, num_streams, streams);
1311 }
1312
1313 /*
1314 generate a file_id from a stat structure
1315 */
1316 struct file_id vfs_file_id_from_sbuf(connection_struct *conn, const SMB_STRUCT_STAT *sbuf)
1317 {
1318 return SMB_VFS_FILE_ID_CREATE(conn, sbuf);
1319 }
1320
1321 int smb_vfs_call_connect(struct vfs_handle_struct *handle,
1322 const char *service, const char *user)
1323 {
1324 VFS_FIND(connect);
1325 return handle->fns->connect_fn(handle, service, user);
1326 }
1327
1328 void smb_vfs_call_disconnect(struct vfs_handle_struct *handle)
1329 {
1330 VFS_FIND(disconnect);
1331 handle->fns->disconnect_fn(handle);
1332 }
1333
1334 uint64_t smb_vfs_call_disk_free(struct vfs_handle_struct *handle,
1335 const char *path, bool small_query,
1336 uint64_t *bsize, uint64_t *dfree,
1337 uint64_t *dsize)
1338 {
1339 VFS_FIND(disk_free);
1340 return handle->fns->disk_free_fn(handle, path, small_query, bsize,
1341 dfree, dsize);
1342 }
1343
1344 int smb_vfs_call_get_quota(struct vfs_handle_struct *handle,
1345 enum SMB_QUOTA_TYPE qtype, unid_t id,
1346 SMB_DISK_QUOTA *qt)
1347 {
1348 VFS_FIND(get_quota);
1349 return handle->fns->get_quota_fn(handle, qtype, id, qt);
1350 }
1351
1352 int smb_vfs_call_set_quota(struct vfs_handle_struct *handle,
1353 enum SMB_QUOTA_TYPE qtype, unid_t id,
1354 SMB_DISK_QUOTA *qt)
1355 {
1356 VFS_FIND(set_quota);
1357 return handle->fns->set_quota_fn(handle, qtype, id, qt);
1358 }
1359
1360 int smb_vfs_call_get_shadow_copy_data(struct vfs_handle_struct *handle,
1361 struct files_struct *fsp,
1362 struct shadow_copy_data *shadow_copy_data,
1363 bool labels)
1364 {
1365 VFS_FIND(get_shadow_copy_data);
1366 return handle->fns->get_shadow_copy_data_fn(handle, fsp,
1367 shadow_copy_data,
1368 labels);
1369 }
1370 int smb_vfs_call_statvfs(struct vfs_handle_struct *handle, const char *path,
1371 struct vfs_statvfs_struct *statbuf)
1372 {
1373 VFS_FIND(statvfs);
1374 return handle->fns->statvfs_fn(handle, path, statbuf);
1375 }
1376
1377 uint32_t smb_vfs_call_fs_capabilities(struct vfs_handle_struct *handle,
1378 enum timestamp_set_resolution *p_ts_res)
1379 {
1380 VFS_FIND(fs_capabilities);
1381 return handle->fns->fs_capabilities_fn(handle, p_ts_res);
1382 }
1383
1384 NTSTATUS smb_vfs_call_get_dfs_referrals(struct vfs_handle_struct *handle,
1385 struct dfs_GetDFSReferral *r)
1386 {
1387 VFS_FIND(get_dfs_referrals);
1388 return handle->fns->get_dfs_referrals_fn(handle, r);
1389 }
1390
1391 SMB_STRUCT_DIR *smb_vfs_call_opendir(struct vfs_handle_struct *handle,
1392 const char *fname, const char *mask,
1393 uint32 attributes)
1394 {
1395 VFS_FIND(opendir);
1396 return handle->fns->opendir_fn(handle, fname, mask, attributes);
1397 }
1398
1399 SMB_STRUCT_DIR *smb_vfs_call_fdopendir(struct vfs_handle_struct *handle,
1400 struct files_struct *fsp,
1401 const char *mask,
1402 uint32 attributes)
1403 {
1404 VFS_FIND(fdopendir);
1405 return handle->fns->fdopendir_fn(handle, fsp, mask, attributes);
1406 }
1407
1408 SMB_STRUCT_DIRENT *smb_vfs_call_readdir(struct vfs_handle_struct *handle,
1409 SMB_STRUCT_DIR *dirp,
1410 SMB_STRUCT_STAT *sbuf)
1411 {
1412 VFS_FIND(readdir);
1413 return handle->fns->readdir_fn(handle, dirp, sbuf);
1414 }
1415
1416 void smb_vfs_call_seekdir(struct vfs_handle_struct *handle,
1417 SMB_STRUCT_DIR *dirp, long offset)
1418 {
1419 VFS_FIND(seekdir);
1420 handle->fns->seekdir_fn(handle, dirp, offset);
1421 }
1422
1423 long smb_vfs_call_telldir(struct vfs_handle_struct *handle,
1424 SMB_STRUCT_DIR *dirp)
1425 {
1426 VFS_FIND(telldir);
1427 return handle->fns->telldir_fn(handle, dirp);
1428 }
1429
1430 void smb_vfs_call_rewind_dir(struct vfs_handle_struct *handle,
1431 SMB_STRUCT_DIR *dirp)
1432 {
1433 VFS_FIND(rewind_dir);
1434 handle->fns->rewind_dir_fn(handle, dirp);
1435 }
1436
1437 int smb_vfs_call_mkdir(struct vfs_handle_struct *handle, const char *path,
1438 mode_t mode)
1439 {
1440 VFS_FIND(mkdir);
1441 return handle->fns->mkdir_fn(handle, path, mode);
1442 }
1443
1444 int smb_vfs_call_rmdir(struct vfs_handle_struct *handle, const char *path)
1445 {
1446 VFS_FIND(rmdir);
1447 return handle->fns->rmdir_fn(handle, path);
1448 }
1449
1450 int smb_vfs_call_closedir(struct vfs_handle_struct *handle,
1451 SMB_STRUCT_DIR *dir)
1452 {
1453 VFS_FIND(closedir);
1454 return handle->fns->closedir_fn(handle, dir);
1455 }
1456
1457 void smb_vfs_call_init_search_op(struct vfs_handle_struct *handle,
1458 SMB_STRUCT_DIR *dirp)
1459 {
1460 VFS_FIND(init_search_op);
1461 handle->fns->init_search_op_fn(handle, dirp);
1462 }
1463
1464 int smb_vfs_call_open(struct vfs_handle_struct *handle,
1465 struct smb_filename *smb_fname, struct files_struct *fsp,
1466 int flags, mode_t mode)
1467 {
1468 VFS_FIND(open);
1469 return handle->fns->open_fn(handle, smb_fname, fsp, flags, mode);
1470 }
1471
1472 NTSTATUS smb_vfs_call_create_file(struct vfs_handle_struct *handle,
1473 struct smb_request *req,
1474 uint16_t root_dir_fid,
1475 struct smb_filename *smb_fname,
1476 uint32_t access_mask,
1477 uint32_t share_access,
1478 uint32_t create_disposition,
1479 uint32_t create_options,
1480 uint32_t file_attributes,
1481 uint32_t oplock_request,
1482 uint64_t allocation_size,
1483 uint32_t private_flags,
1484 struct security_descriptor *sd,
1485 struct ea_list *ea_list,
1486 files_struct **result,
1487 int *pinfo)
1488 {
1489 VFS_FIND(create_file);
1490 return handle->fns->create_file_fn(
1491 handle, req, root_dir_fid, smb_fname, access_mask,
1492 share_access, create_disposition, create_options,
1493 file_attributes, oplock_request, allocation_size,
1494 private_flags, sd, ea_list,
1495 result, pinfo);
1496 }
1497
1498 int smb_vfs_call_close(struct vfs_handle_struct *handle,
1499 struct files_struct *fsp)
1500 {
1501 VFS_FIND(close);
1502 return handle->fns->close_fn(handle, fsp);
1503 }
1504
1505 ssize_t smb_vfs_call_read(struct vfs_handle_struct *handle,
1506 struct files_struct *fsp, void *data, size_t n)
1507 {
1508 VFS_FIND(read);
1509 return handle->fns->read_fn(handle, fsp, data, n);
1510 }
1511
1512 ssize_t smb_vfs_call_pread(struct vfs_handle_struct *handle,
1513 struct files_struct *fsp, void *data, size_t n,
1514 SMB_OFF_T offset)
1515 {
1516 VFS_FIND(pread);
1517 return handle->fns->pread_fn(handle, fsp, data, n, offset);
1518 }
1519
1520 ssize_t smb_vfs_call_write(struct vfs_handle_struct *handle,
1521 struct files_struct *fsp, const void *data,
1522 size_t n)
1523 {
1524 VFS_FIND(write);
1525 return handle->fns->write_fn(handle, fsp, data, n);
1526 }
1527
1528 ssize_t smb_vfs_call_pwrite(struct vfs_handle_struct *handle,
1529 struct files_struct *fsp, const void *data,
1530 size_t n, SMB_OFF_T offset)
1531 {
1532 VFS_FIND(pwrite);
1533 return handle->fns->pwrite_fn(handle, fsp, data, n, offset);
1534 }
1535
1536 SMB_OFF_T smb_vfs_call_lseek(struct vfs_handle_struct *handle,
1537 struct files_struct *fsp, SMB_OFF_T offset,
1538 int whence)
1539 {
1540 VFS_FIND(lseek);
1541 return handle->fns->lseek_fn(handle, fsp, offset, whence);
1542 }
1543
1544 ssize_t smb_vfs_call_sendfile(struct vfs_handle_struct *handle, int tofd,
1545 files_struct *fromfsp, const DATA_BLOB *header,
1546 SMB_OFF_T offset, size_t count)
1547 {
1548 VFS_FIND(sendfile);
1549 return handle->fns->sendfile_fn(handle, tofd, fromfsp, header, offset,
1550 count);
1551 }
1552
1553 ssize_t smb_vfs_call_recvfile(struct vfs_handle_struct *handle, int fromfd,
1554 files_struct *tofsp, SMB_OFF_T offset,
1555 size_t count)
1556 {
1557 VFS_FIND(recvfile);
1558 return handle->fns->recvfile_fn(handle, fromfd, tofsp, offset, count);
1559 }
1560
1561 int smb_vfs_call_rename(struct vfs_handle_struct *handle,
1562 const struct smb_filename *smb_fname_src,
1563 const struct smb_filename *smb_fname_dst)
1564 {
1565 VFS_FIND(rename);
1566 return handle->fns->rename_fn(handle, smb_fname_src, smb_fname_dst);
1567 }
1568
1569 int smb_vfs_call_fsync(struct vfs_handle_struct *handle,
1570 struct files_struct *fsp)
1571 {
1572 VFS_FIND(fsync);
1573 return handle->fns->fsync_fn(handle, fsp);
1574 }
1575
1576 int smb_vfs_call_stat(struct vfs_handle_struct *handle,
1577 struct smb_filename *smb_fname)
1578 {
1579 VFS_FIND(stat);
1580 return handle->fns->stat_fn(handle, smb_fname);
1581 }
1582
1583 int smb_vfs_call_fstat(struct vfs_handle_struct *handle,
1584 struct files_struct *fsp, SMB_STRUCT_STAT *sbuf)
1585 {
1586 VFS_FIND(fstat);
1587 return handle->fns->fstat_fn(handle, fsp, sbuf);
1588 }
1589
1590 int smb_vfs_call_lstat(struct vfs_handle_struct *handle,
1591 struct smb_filename *smb_filename)
1592 {
1593 VFS_FIND(lstat);
1594 return handle->fns->lstat_fn(handle, smb_filename);
1595 }
1596
1597 uint64_t smb_vfs_call_get_alloc_size(struct vfs_handle_struct *handle,
1598 struct files_struct *fsp,
1599 const SMB_STRUCT_STAT *sbuf)
1600 {
1601 VFS_FIND(get_alloc_size);
1602 return handle->fns->get_alloc_size_fn(handle, fsp, sbuf);
1603 }
1604
1605 int smb_vfs_call_unlink(struct vfs_handle_struct *handle,
1606 const struct smb_filename *smb_fname)
1607 {
1608 VFS_FIND(unlink);
1609 return handle->fns->unlink_fn(handle, smb_fname);
1610 }
1611
1612 int smb_vfs_call_chmod(struct vfs_handle_struct *handle, const char *path,
1613 mode_t mode)
1614 {
1615 VFS_FIND(chmod);
1616 return handle->fns->chmod_fn(handle, path, mode);
1617 }
1618
1619 int smb_vfs_call_fchmod(struct vfs_handle_struct *handle,
1620 struct files_struct *fsp, mode_t mode)
1621 {
1622 VFS_FIND(fchmod);
1623 return handle->fns->fchmod_fn(handle, fsp, mode);
1624 }
1625
1626 int smb_vfs_call_chown(struct vfs_handle_struct *handle, const char *path,
1627 uid_t uid, gid_t gid)
1628 {
1629 VFS_FIND(chown);
1630 return handle->fns->chown_fn(handle, path, uid, gid);
1631 }
1632
1633 int smb_vfs_call_fchown(struct vfs_handle_struct *handle,
1634 struct files_struct *fsp, uid_t uid, gid_t gid)
1635 {
1636 VFS_FIND(fchown);
1637 return handle->fns->fchown_fn(handle, fsp, uid, gid);
1638 }
1639
1640 int smb_vfs_call_lchown(struct vfs_handle_struct *handle, const char *path,
1641 uid_t uid, gid_t gid)
1642 {
1643 VFS_FIND(lchown);
1644 return handle->fns->lchown_fn(handle, path, uid, gid);
1645 }
1646
1647 NTSTATUS vfs_chown_fsp(files_struct *fsp, uid_t uid, gid_t gid)
1648 {
1649 int ret;
1650 bool as_root = false;
1651 const char *path;
1652 char *saved_dir = NULL;
1653 char *parent_dir = NULL;
1654 NTSTATUS status;
1655
1656 if (fsp->fh->fd != -1) {
1657 /* Try fchown. */
1658 ret = SMB_VFS_FCHOWN(fsp, uid, gid);
1659 if (ret == 0) {
1660 return NT_STATUS_OK;
1661 }
1662 if (ret == -1 && errno != ENOSYS) {
1663 return map_nt_error_from_unix(errno);
1664 }
1665 }
1666
1667 as_root = (geteuid() == 0);
1668
1669 if (as_root) {
1670 /*
1671 * We are being asked to chown as root. Make
1672 * sure we chdir() into the path to pin it,
1673 * and always act using lchown to ensure we
1674 * don't deref any symbolic links.
1675 */
1676 const char *final_component = NULL;
1677 struct smb_filename local_fname;
1678
1679 saved_dir = vfs_GetWd(talloc_tos(),fsp->conn);
1680 if (!saved_dir) {
1681 status = map_nt_error_from_unix(errno);
1682 DEBUG(0,("vfs_chown_fsp: failed to get "
1683 "current working directory. Error was %s\n",
1684 strerror(errno)));
1685 return status;
1686 }
1687
1688 if (!parent_dirname(talloc_tos(),
1689 fsp->fsp_name->base_name,
1690 &parent_dir,
1691 &final_component)) {
1692 return NT_STATUS_NO_MEMORY;
1693 }
1694
1695 /* cd into the parent dir to pin it. */
1696 ret = vfs_ChDir(fsp->conn, parent_dir);
1697 if (ret == -1) {
1698 return map_nt_error_from_unix(errno);
1699 }
1700
1701 ZERO_STRUCT(local_fname);
1702 local_fname.base_name = discard_const_p(char, final_component);
1703
1704 /* Must use lstat here. */
1705 ret = SMB_VFS_LSTAT(fsp->conn, &local_fname);
1706 if (ret == -1) {
1707 status = map_nt_error_from_unix(errno);
1708 goto out;
1709 }
1710
1711 /* Ensure it matches the fsp stat. */
1712 if (!check_same_stat(&local_fname.st, &fsp->fsp_name->st)) {
1713 status = NT_STATUS_ACCESS_DENIED;
1714 goto out;
1715 }
1716 path = final_component;
1717 } else {
1718 path = fsp->fsp_name->base_name;
1719 }
1720
1721 if (fsp->posix_open || as_root) {
1722 ret = SMB_VFS_LCHOWN(fsp->conn,
1723 path,
1724 uid, gid);
1725 } else {
1726 ret = SMB_VFS_CHOWN(fsp->conn,
1727 path,
1728 uid, gid);
1729 }
1730
1731 if (ret == 0) {
1732 status = NT_STATUS_OK;
1733 } else {
1734 status = map_nt_error_from_unix(errno);
1735 }
1736
1737 out:
1738
1739 if (as_root) {
1740 vfs_ChDir(fsp->conn,saved_dir);
1741 TALLOC_FREE(saved_dir);
1742 TALLOC_FREE(parent_dir);
1743 }
1744 return status;
1745 }
1746
1747 int smb_vfs_call_chdir(struct vfs_handle_struct *handle, const char *path)
1748 {
1749 VFS_FIND(chdir);
1750 return handle->fns->chdir_fn(handle, path);
1751 }
1752
1753 char *smb_vfs_call_getwd(struct vfs_handle_struct *handle)
1754 {
1755 VFS_FIND(getwd);
1756 return handle->fns->getwd_fn(handle);
1757 }
1758
1759 int smb_vfs_call_ntimes(struct vfs_handle_struct *handle,
1760 const struct smb_filename *smb_fname,
1761 struct smb_file_time *ft)
1762 {
1763 VFS_FIND(ntimes);
1764 return handle->fns->ntimes_fn(handle, smb_fname, ft);
1765 }
1766
1767 int smb_vfs_call_ftruncate(struct vfs_handle_struct *handle,
1768 struct files_struct *fsp, SMB_OFF_T offset)
1769 {
1770 VFS_FIND(ftruncate);
1771 return handle->fns->ftruncate_fn(handle, fsp, offset);
1772 }
1773
1774 int smb_vfs_call_fallocate(struct vfs_handle_struct *handle,
1775 struct files_struct *fsp,
1776 enum vfs_fallocate_mode mode,
1777 SMB_OFF_T offset,
1778 SMB_OFF_T len)
1779 {
1780 VFS_FIND(fallocate);
1781 return handle->fns->fallocate_fn(handle, fsp, mode, offset, len);
1782 }
1783
1784 int smb_vfs_call_kernel_flock(struct vfs_handle_struct *handle,
1785 struct files_struct *fsp, uint32 share_mode,
1786 uint32_t access_mask)
1787 {
1788 VFS_FIND(kernel_flock);
1789 return handle->fns->kernel_flock_fn(handle, fsp, share_mode,
1790 access_mask);
1791 }
1792
1793 int smb_vfs_call_linux_setlease(struct vfs_handle_struct *handle,
1794 struct files_struct *fsp, int leasetype)
1795 {
1796 VFS_FIND(linux_setlease);
1797 return handle->fns->linux_setlease_fn(handle, fsp, leasetype);
1798 }
1799
1800 int smb_vfs_call_symlink(struct vfs_handle_struct *handle, const char *oldpath,
1801 const char *newpath)
1802 {
1803 VFS_FIND(symlink);
1804 return handle->fns->symlink_fn(handle, oldpath, newpath);
1805 }
1806
1807 int smb_vfs_call_readlink(struct vfs_handle_struct *handle,
1808 const char *path, char *buf, size_t bufsiz)
1809 {
1810 VFS_FIND(readlink);
1811 return handle->fns->readlink_fn(handle, path, buf, bufsiz);
1812 }
1813
1814 int smb_vfs_call_link(struct vfs_handle_struct *handle, const char *oldpath,
1815 const char *newpath)
1816 {
1817 VFS_FIND(link);
1818 return handle->fns->link_fn(handle, oldpath, newpath);
1819 }
1820
1821 int smb_vfs_call_mknod(struct vfs_handle_struct *handle, const char *path,
1822 mode_t mode, SMB_DEV_T dev)
1823 {
1824 VFS_FIND(mknod);
1825 return handle->fns->mknod_fn(handle, path, mode, dev);
1826 }
1827
1828 char *smb_vfs_call_realpath(struct vfs_handle_struct *handle, const char *path)
1829 {
1830 VFS_FIND(realpath);
1831 return handle->fns->realpath_fn(handle, path);
1832 }
1833
1834 NTSTATUS smb_vfs_call_notify_watch(struct vfs_handle_struct *handle,
1835 struct sys_notify_context *ctx,
1836 struct notify_entry *e,
1837 const char *path,
1838 void (*callback)(struct sys_notify_context *ctx,
1839 void *private_data,
1840 struct notify_event *ev),
1841 void *private_data, void *handle_p)
1842 {
1843 VFS_FIND(notify_watch);
1844 return handle->fns->notify_watch_fn(handle, ctx, e, path, callback,
1845 private_data, handle_p);
1846 }
1847
1848 int smb_vfs_call_chflags(struct vfs_handle_struct *handle, const char *path,
1849 unsigned int flags)
1850 {
1851 VFS_FIND(chflags);
1852 return handle->fns->chflags_fn(handle, path, flags);
1853 }
1854
1855 struct file_id smb_vfs_call_file_id_create(struct vfs_handle_struct *handle,
1856 const SMB_STRUCT_STAT *sbuf)
1857 {
1858 VFS_FIND(file_id_create);
1859 return handle->fns->file_id_create_fn(handle, sbuf);
1860 }
1861
1862 NTSTATUS smb_vfs_call_streaminfo(struct vfs_handle_struct *handle,
1863 struct files_struct *fsp,
1864 const char *fname,
1865 TALLOC_CTX *mem_ctx,
1866 unsigned int *num_streams,
1867 struct stream_struct **streams)
1868 {
1869 VFS_FIND(streaminfo);
1870 return handle->fns->streaminfo_fn(handle, fsp, fname, mem_ctx,
1871 num_streams, streams);
1872 }
1873
1874 int smb_vfs_call_get_real_filename(struct vfs_handle_struct *handle,
1875 const char *path, const char *name,
1876 TALLOC_CTX *mem_ctx, char **found_name)
1877 {
1878 VFS_FIND(get_real_filename);
1879 return handle->fns->get_real_filename_fn(handle, path, name, mem_ctx,
1880 found_name);
1881 }
1882
1883 const char *smb_vfs_call_connectpath(struct vfs_handle_struct *handle,
1884 const char *filename)
1885 {
1886 VFS_FIND(connectpath);
1887 return handle->fns->connectpath_fn(handle, filename);
1888 }
1889
1890 bool smb_vfs_call_strict_lock(struct vfs_handle_struct *handle,
1891 struct files_struct *fsp,
1892 struct lock_struct *plock)
1893 {
1894 VFS_FIND(strict_lock);
1895 return handle->fns->strict_lock_fn(handle, fsp, plock);
1896 }
1897
1898 void smb_vfs_call_strict_unlock(struct vfs_handle_struct *handle,
1899 struct files_struct *fsp,
1900 struct lock_struct *plock)
1901 {
1902 VFS_FIND(strict_unlock);
1903 handle->fns->strict_unlock_fn(handle, fsp, plock);
1904 }
1905
1906 NTSTATUS smb_vfs_call_translate_name(struct vfs_handle_struct *handle,
1907 const char *name,
1908 enum vfs_translate_direction direction,
1909 TALLOC_CTX *mem_ctx,
1910 char **mapped_name)
1911 {
1912 VFS_FIND(translate_name);
1913 return handle->fns->translate_name_fn(handle, name, direction, mem_ctx,
1914 mapped_name);
1915 }
1916
1917 NTSTATUS smb_vfs_call_fsctl(struct vfs_handle_struct *handle,
1918 struct files_struct *fsp,
1919 TALLOC_CTX *ctx,
1920 uint32_t function,
1921 uint16_t req_flags,
1922 const uint8_t *in_data,
1923 uint32_t in_len,
1924 uint8_t **out_data,
1925 uint32_t max_out_len,
1926 uint32_t *out_len)
1927 {
1928 VFS_FIND(fsctl);
1929 return handle->fns->fsctl_fn(handle, fsp, ctx, function, req_flags,
1930 in_data, in_len, out_data, max_out_len,
1931 out_len);
1932 }
1933
1934 NTSTATUS smb_vfs_call_fget_nt_acl(struct vfs_handle_struct *handle,
1935 struct files_struct *fsp,
1936 uint32 security_info,
1937 struct security_descriptor **ppdesc)
1938 {
1939 VFS_FIND(fget_nt_acl);
1940 return handle->fns->fget_nt_acl_fn(handle, fsp, security_info,
1941 ppdesc);
1942 }
1943
1944 NTSTATUS smb_vfs_call_get_nt_acl(struct vfs_handle_struct *handle,
1945 const char *name,
1946 uint32 security_info,
1947 struct security_descriptor **ppdesc)
1948 {
1949 VFS_FIND(get_nt_acl);
1950 return handle->fns->get_nt_acl_fn(handle, name, security_info, ppdesc);
1951 }
1952
1953 NTSTATUS smb_vfs_call_fset_nt_acl(struct vfs_handle_struct *handle,
1954 struct files_struct *fsp,
1955 uint32 security_info_sent,
1956 const struct security_descriptor *psd)
1957 {
1958 VFS_FIND(fset_nt_acl);
1959 return handle->fns->fset_nt_acl_fn(handle, fsp, security_info_sent,
1960 psd);
1961 }
1962
1963 int smb_vfs_call_chmod_acl(struct vfs_handle_struct *handle, const char *name,
1964 mode_t mode)
1965 {
1966 VFS_FIND(chmod_acl);
1967 return handle->fns->chmod_acl_fn(handle, name, mode);
1968 }
1969
1970 int smb_vfs_call_fchmod_acl(struct vfs_handle_struct *handle,
1971 struct files_struct *fsp, mode_t mode)
1972 {
1973 VFS_FIND(fchmod_acl);
1974 return handle->fns->fchmod_acl_fn(handle, fsp, mode);
1975 }
1976
1977 int smb_vfs_call_sys_acl_get_entry(struct vfs_handle_struct *handle,
1978 SMB_ACL_T theacl, int entry_id,
1979 SMB_ACL_ENTRY_T *entry_p)
1980 {
1981 VFS_FIND(sys_acl_get_entry);
1982 return handle->fns->sys_acl_get_entry_fn(handle, theacl, entry_id,
1983 entry_p);
1984 }
1985
1986 int smb_vfs_call_sys_acl_get_tag_type(struct vfs_handle_struct *handle,
1987 SMB_ACL_ENTRY_T entry_d,
1988 SMB_ACL_TAG_T *tag_type_p)
1989 {
1990 VFS_FIND(sys_acl_get_tag_type);
1991 return handle->fns->sys_acl_get_tag_type_fn(handle, entry_d,
1992 tag_type_p);
1993 }
1994
1995 int smb_vfs_call_sys_acl_get_permset(struct vfs_handle_struct *handle,
1996 SMB_ACL_ENTRY_T entry_d,
1997 SMB_ACL_PERMSET_T *permset_p)
1998 {
1999 VFS_FIND(sys_acl_get_permset);
2000 return handle->fns->sys_acl_get_permset_fn(handle, entry_d, permset_p);
2001 }
2002
2003 void * smb_vfs_call_sys_acl_get_qualifier(struct vfs_handle_struct *handle,
2004 SMB_ACL_ENTRY_T entry_d)
2005 {
2006 VFS_FIND(sys_acl_get_qualifier);
2007 return handle->fns->sys_acl_get_qualifier_fn(handle, entry_d);
2008 }
2009
2010 SMB_ACL_T smb_vfs_call_sys_acl_get_file(struct vfs_handle_struct *handle,
2011 const char *path_p,
2012 SMB_ACL_TYPE_T type)
2013 {
2014 VFS_FIND(sys_acl_get_file);
2015 return handle->fns->sys_acl_get_file_fn(handle, path_p, type);
2016 }
2017
2018 SMB_ACL_T smb_vfs_call_sys_acl_get_fd(struct vfs_handle_struct *handle,
2019 struct files_struct *fsp)
2020 {
2021 VFS_FIND(sys_acl_get_fd);
2022 return handle->fns->sys_acl_get_fd_fn(handle, fsp);
2023 }
2024
2025 int smb_vfs_call_sys_acl_clear_perms(struct vfs_handle_struct *handle,
2026 SMB_ACL_PERMSET_T permset)
2027 {
2028 VFS_FIND(sys_acl_clear_perms);
2029 return handle->fns->sys_acl_clear_perms_fn(handle, permset);
2030 }
2031
2032 int smb_vfs_call_sys_acl_add_perm(struct vfs_handle_struct *handle,
2033 SMB_ACL_PERMSET_T permset,
2034 SMB_ACL_PERM_T perm)
2035 {
2036 VFS_FIND(sys_acl_add_perm);
2037 return handle->fns->sys_acl_add_perm_fn(handle, permset, perm);
2038 }
2039
2040 char * smb_vfs_call_sys_acl_to_text(struct vfs_handle_struct *handle,
2041 SMB_ACL_T theacl, ssize_t *plen)
2042 {
2043 VFS_FIND(sys_acl_to_text);
2044 return handle->fns->sys_acl_to_text_fn(handle, theacl, plen);
2045 }
2046
2047 SMB_ACL_T smb_vfs_call_sys_acl_init(struct vfs_handle_struct *handle,
2048 int count)
2049 {
2050 VFS_FIND(sys_acl_init);
2051 return handle->fns->sys_acl_init_fn(handle, count);
2052 }
2053
2054 int smb_vfs_call_sys_acl_create_entry(struct vfs_handle_struct *handle,
2055 SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
2056 {
2057 VFS_FIND(sys_acl_create_entry);
2058 return handle->fns->sys_acl_create_entry_fn(handle, pacl, pentry);
2059 }
2060
2061 int smb_vfs_call_sys_acl_set_tag_type(struct vfs_handle_struct *handle,
2062 SMB_ACL_ENTRY_T entry,
2063 SMB_ACL_TAG_T tagtype)
2064 {
2065 VFS_FIND(sys_acl_set_tag_type);
2066 return handle->fns->sys_acl_set_tag_type_fn(handle, entry, tagtype);
2067 }
2068
2069 int smb_vfs_call_sys_acl_set_qualifier(struct vfs_handle_struct *handle,
2070 SMB_ACL_ENTRY_T entry, void *qual)
2071 {
2072 VFS_FIND(sys_acl_set_qualifier);
2073 return handle->fns->sys_acl_set_qualifier_fn(handle, entry, qual);
2074 }
2075
2076 int smb_vfs_call_sys_acl_set_permset(struct vfs_handle_struct *handle,
2077 SMB_ACL_ENTRY_T entry,
2078 SMB_ACL_PERMSET_T permset)
2079 {
2080 VFS_FIND(sys_acl_set_permset);
2081 return handle->fns->sys_acl_set_permset_fn(handle, entry, permset);
2082 }
2083
2084 int smb_vfs_call_sys_acl_valid(struct vfs_handle_struct *handle,
2085 SMB_ACL_T theacl)
2086 {
2087 VFS_FIND(sys_acl_valid);
2088 return handle->fns->sys_acl_valid_fn(handle, theacl);
2089 }
2090
2091 int smb_vfs_call_sys_acl_set_file(struct vfs_handle_struct *handle,
2092 const char *name, SMB_ACL_TYPE_T acltype,
2093 SMB_ACL_T theacl)
2094 {
2095 VFS_FIND(sys_acl_set_file);
2096 return handle->fns->sys_acl_set_file_fn(handle, name, acltype, theacl);
2097 }
2098
2099 int smb_vfs_call_sys_acl_set_fd(struct vfs_handle_struct *handle,
2100 struct files_struct *fsp, SMB_ACL_T theacl)
2101 {
2102 VFS_FIND(sys_acl_set_fd);
2103 return handle->fns->sys_acl_set_fd_fn(handle, fsp, theacl);
2104 }
2105
2106 int smb_vfs_call_sys_acl_delete_def_file(struct vfs_handle_struct *handle,
2107 const char *path)
2108 {
2109 VFS_FIND(sys_acl_delete_def_file);
2110 return handle->fns->sys_acl_delete_def_file_fn(handle, path);
2111 }
2112
2113 int smb_vfs_call_sys_acl_get_perm(struct vfs_handle_struct *handle,
2114 SMB_ACL_PERMSET_T permset,
2115 SMB_ACL_PERM_T perm)
2116 {
2117 VFS_FIND(sys_acl_get_perm);
2118 return handle->fns->sys_acl_get_perm_fn(handle, permset, perm);
2119 }
2120
2121 int smb_vfs_call_sys_acl_free_text(struct vfs_handle_struct *handle,
2122 char *text)
2123 {
2124 VFS_FIND(sys_acl_free_text);
2125 return handle->fns->sys_acl_free_text_fn(handle, text);
2126 }
2127
2128 int smb_vfs_call_sys_acl_free_acl(struct vfs_handle_struct *handle,
2129 SMB_ACL_T posix_acl)
2130 {
2131 VFS_FIND(sys_acl_free_acl);
2132 return handle->fns->sys_acl_free_acl_fn(handle, posix_acl);
2133 }
2134
2135 int smb_vfs_call_sys_acl_free_qualifier(struct vfs_handle_struct *handle,
2136 void *qualifier, SMB_ACL_TAG_T tagtype)
2137 {
2138 VFS_FIND(sys_acl_free_qualifier);
2139 return handle->fns->sys_acl_free_qualifier_fn(handle, qualifier,
2140 tagtype);
2141 }
2142
2143 ssize_t smb_vfs_call_getxattr(struct vfs_handle_struct *handle,
2144 const char *path, const char *name, void *value,
2145 size_t size)
2146 {
2147 VFS_FIND(getxattr);
2148 return handle->fns->getxattr_fn(handle, path, name, value, size);
2149 }
2150
2151 ssize_t smb_vfs_call_lgetxattr(struct vfs_handle_struct *handle,
2152 const char *path, const char *name, void *value,
2153 size_t size)
2154 {
2155 VFS_FIND(lgetxattr);
2156 return handle->fns->lgetxattr_fn(handle, path, name, value, size);
2157 }
2158
2159 ssize_t smb_vfs_call_fgetxattr(struct vfs_handle_struct *handle,
2160 struct files_struct *fsp, const char *name,
2161 void *value, size_t size)
2162 {
2163 VFS_FIND(fgetxattr);
2164 return handle->fns->fgetxattr_fn(handle, fsp, name, value, size);
2165 }
2166
2167 ssize_t smb_vfs_call_listxattr(struct vfs_handle_struct *handle,
2168 const char *path, char *list, size_t size)
2169 {
2170 VFS_FIND(listxattr);
2171 return handle->fns->listxattr_fn(handle, path, list, size);
2172 }
2173
2174 ssize_t smb_vfs_call_llistxattr(struct vfs_handle_struct *handle,
2175 const char *path, char *list, size_t size)
2176 {
2177 VFS_FIND(llistxattr);
2178 return handle->fns->llistxattr_fn(handle, path, list, size);
2179 }
2180
2181 ssize_t smb_vfs_call_flistxattr(struct vfs_handle_struct *handle,
2182 struct files_struct *fsp, char *list,
2183 size_t size)
2184 {
2185 VFS_FIND(flistxattr);
2186 return handle->fns->flistxattr_fn(handle, fsp, list, size);
2187 }
2188
2189 int smb_vfs_call_removexattr(struct vfs_handle_struct *handle,
2190 const char *path, const char *name)
2191 {
2192 VFS_FIND(removexattr);
2193 return handle->fns->removexattr_fn(handle, path, name);
2194 }
2195
2196 int smb_vfs_call_lremovexattr(struct vfs_handle_struct *handle,
2197 const char *path, const char *name)
2198 {
2199 VFS_FIND(lremovexattr);
2200 return handle->fns->lremovexattr_fn(handle, path, name);
2201 }
2202
2203 int smb_vfs_call_fremovexattr(struct vfs_handle_struct *handle,
2204 struct files_struct *fsp, const char *name)
2205 {
2206 VFS_FIND(fremovexattr);
2207 return handle->fns->fremovexattr_fn(handle, fsp, name);
2208 }
2209
2210 int smb_vfs_call_setxattr(struct vfs_handle_struct *handle, const char *path,
2211 const char *name, const void *value, size_t size,
2212 int flags)
2213 {
2214 VFS_FIND(setxattr);
2215 return handle->fns->setxattr_fn(handle, path, name, value, size, flags);
2216 }
2217
2218 int smb_vfs_call_lsetxattr(struct vfs_handle_struct *handle, const char *path,
2219 const char *name, const void *value, size_t size,
2220 int flags)
2221 {
2222 VFS_FIND(lsetxattr);
2223 return handle->fns->lsetxattr_fn(handle, path, name, value, size,
2224 flags);
2225 }
2226
2227 int smb_vfs_call_fsetxattr(struct vfs_handle_struct *handle,
2228 struct files_struct *fsp, const char *name,
2229 const void *value, size_t size, int flags)
2230 {
2231 VFS_FIND(fsetxattr);
2232 return handle->fns->fsetxattr_fn(handle, fsp, name, value, size, flags);
2233 }
2234
2235 int smb_vfs_call_aio_read(struct vfs_handle_struct *handle,
2236 struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
2237 {
2238 VFS_FIND(aio_read);
2239 return handle->fns->aio_read_fn(handle, fsp, aiocb);
2240 }
2241
2242 int smb_vfs_call_aio_write(struct vfs_handle_struct *handle,
2243 struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
2244 {
2245 VFS_FIND(aio_write);
2246 return handle->fns->aio_write_fn(handle, fsp, aiocb);
2247 }
2248
2249 ssize_t smb_vfs_call_aio_return(struct vfs_handle_struct *handle,
2250 struct files_struct *fsp,
2251 SMB_STRUCT_AIOCB *aiocb)
2252 {
2253 VFS_FIND(aio_return);
2254 return handle->fns->aio_return_fn(handle, fsp, aiocb);
2255 }
2256
2257 int smb_vfs_call_aio_cancel(struct vfs_handle_struct *handle,
2258 struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
2259 {
2260 VFS_FIND(aio_cancel);
2261 return handle->fns->aio_cancel_fn(handle, fsp, aiocb);
2262 }
2263
2264 int smb_vfs_call_aio_error(struct vfs_handle_struct *handle,
2265 struct files_struct *fsp,
2266 SMB_STRUCT_AIOCB *aiocb)
2267 {
2268 VFS_FIND(aio_error);
2269 return handle->fns->aio_error_fn(handle, fsp, aiocb);
2270 }
2271
2272 int smb_vfs_call_aio_fsync(struct vfs_handle_struct *handle,
2273 struct files_struct *fsp, int op,
2274 SMB_STRUCT_AIOCB *aiocb)
2275 {
2276 VFS_FIND(aio_fsync);
2277 return handle->fns->aio_fsync_fn(handle, fsp, op, aiocb);
2278 }
2279
2280 int smb_vfs_call_aio_suspend(struct vfs_handle_struct *handle,
2281 struct files_struct *fsp,
2282 const SMB_STRUCT_AIOCB * const aiocb[], int n,
2283 const struct timespec *timeout)
2284 {
2285 VFS_FIND(aio_suspend);
2286 return handle->fns->aio_suspend_fn(handle, fsp, aiocb, n, timeout);
2287 }
2288
2289 bool smb_vfs_call_aio_force(struct vfs_handle_struct *handle,
2290 struct files_struct *fsp)
2291 {
2292 VFS_FIND(aio_force);
2293 return handle->fns->aio_force_fn(handle, fsp);
2294 }
2295
2296 bool smb_vfs_call_is_offline(struct vfs_handle_struct *handle,
2297 const struct smb_filename *fname,
2298 SMB_STRUCT_STAT *sbuf)
2299 {
2300 VFS_FIND(is_offline);
2301 return handle->fns->is_offline_fn(handle, fname, sbuf);
2302 }
2303
2304 int smb_vfs_call_set_offline(struct vfs_handle_struct *handle,
2305 const struct smb_filename *fname)
2306 {
2307 VFS_FIND(set_offline);
2308 return handle->fns->set_offline_fn(handle, fname);
2309 }
reg import