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