2 Unix SMB/Netbios implementation.
4 VFS initialisation and support functions
5 Copyright (C) Tim Potter 1999
6 Copyright (C) Alexander Bokovoy 2002
7 Copyright (C) James Peach 2006
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 This work was sponsored by Optifacio Software Services, Inc.
26 #include "smbd/globals.h"
29 #define DBGC_CLASS DBGC_VFS
33 struct vfs_init_function_entry
{
35 const vfs_op_tuple
*vfs_op_tuples
;
36 struct vfs_init_function_entry
*prev
, *next
;
39 /****************************************************************************
40 maintain the list of available backends
41 ****************************************************************************/
43 static struct vfs_init_function_entry
*vfs_find_backend_entry(const char *name
)
45 struct vfs_init_function_entry
*entry
= backends
;
47 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name
));
50 if (strcmp(entry
->name
, name
)==0) return entry
;
57 NTSTATUS
smb_register_vfs(int version
, const char *name
, const vfs_op_tuple
*vfs_op_tuples
)
59 struct vfs_init_function_entry
*entry
= backends
;
61 if ((version
!= SMB_VFS_INTERFACE_VERSION
)) {
62 DEBUG(0, ("Failed to register vfs module.\n"
63 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
64 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
65 "Please recompile against the current Samba Version!\n",
66 version
, SMB_VFS_INTERFACE_VERSION
));
67 return NT_STATUS_OBJECT_TYPE_MISMATCH
;
70 if (!name
|| !name
[0] || !vfs_op_tuples
) {
71 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
72 return NT_STATUS_INVALID_PARAMETER
;
75 if (vfs_find_backend_entry(name
)) {
76 DEBUG(0,("VFS module %s already loaded!\n", name
));
77 return NT_STATUS_OBJECT_NAME_COLLISION
;
80 entry
= SMB_XMALLOC_P(struct vfs_init_function_entry
);
81 entry
->name
= smb_xstrdup(name
);
82 entry
->vfs_op_tuples
= vfs_op_tuples
;
84 DLIST_ADD(backends
, entry
);
85 DEBUG(5, ("Successfully added vfs backend '%s'\n", name
));
89 /****************************************************************************
90 initialise default vfs hooks
91 ****************************************************************************/
93 static void vfs_init_default(connection_struct
*conn
)
95 DEBUG(3, ("Initialising default vfs hooks\n"));
96 vfs_init_custom(conn
, DEFAULT_VFS_MODULE_NAME
);
99 /****************************************************************************
100 initialise custom vfs hooks
101 ****************************************************************************/
103 static inline void vfs_set_operation(struct vfs_ops
* vfs
, vfs_op_type which
,
104 struct vfs_handle_struct
* handle
, void * op
)
106 ((struct vfs_handle_struct
**)&vfs
->handles
)[which
] = handle
;
107 ((void **)(void *)&vfs
->ops
)[which
] = op
;
110 bool vfs_init_custom(connection_struct
*conn
, const char *vfs_object
)
112 const vfs_op_tuple
*ops
;
113 char *module_path
= NULL
;
114 char *module_name
= NULL
;
115 char *module_param
= NULL
, *p
;
117 vfs_handle_struct
*handle
;
118 const struct vfs_init_function_entry
*entry
;
120 if (!conn
||!vfs_object
||!vfs_object
[0]) {
121 DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
129 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object
));
131 module_path
= smb_xstrdup(vfs_object
);
133 p
= strchr_m(module_path
, ':');
138 trim_char(module_param
, ' ', ' ');
141 trim_char(module_path
, ' ', ' ');
143 module_name
= smb_xstrdup(module_path
);
145 if ((module_name
[0] == '/') &&
146 (strcmp(module_path
, DEFAULT_VFS_MODULE_NAME
) != 0)) {
149 * Extract the module name from the path. Just use the base
150 * name of the last path component.
153 SAFE_FREE(module_name
);
154 module_name
= smb_xstrdup(strrchr_m(module_path
, '/')+1);
156 p
= strchr_m(module_name
, '.');
163 /* First, try to load the module with the new module system */
164 entry
= vfs_find_backend_entry(module_name
);
168 DEBUG(5, ("vfs module [%s] not loaded - trying to load...\n",
171 status
= smb_probe_module("vfs", module_path
);
172 if (!NT_STATUS_IS_OK(status
)) {
173 DEBUG(0, ("error probing vfs module '%s': %s\n",
174 module_path
, nt_errstr(status
)));
178 entry
= vfs_find_backend_entry(module_name
);
180 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object
));
185 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object
));
186 if ((ops
= entry
->vfs_op_tuples
) == NULL
) {
187 DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object
));
191 handle
= TALLOC_ZERO_P(conn
, vfs_handle_struct
);
193 DEBUG(0,("TALLOC_ZERO() failed!\n"));
196 memcpy(&handle
->vfs_next
, &conn
->vfs
, sizeof(struct vfs_ops
));
199 handle
->param
= talloc_strdup(conn
, module_param
);
201 DLIST_ADD(conn
->vfs_handles
, handle
);
203 for(i
=0; ops
[i
].op
!= NULL
; i
++) {
204 DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i
, ops
[i
].type
, ops
[i
].layer
));
205 if(ops
[i
].layer
== SMB_VFS_LAYER_OPAQUE
) {
206 /* If this operation was already made opaque by different module, it
207 * will be overridden here.
209 DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops
[i
].type
, vfs_object
));
210 vfs_set_operation(&conn
->vfs_opaque
, ops
[i
].type
, handle
, ops
[i
].op
);
212 /* Change current VFS disposition*/
213 DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops
[i
].type
, vfs_object
));
214 vfs_set_operation(&conn
->vfs
, ops
[i
].type
, handle
, ops
[i
].op
);
217 SAFE_FREE(module_path
);
218 SAFE_FREE(module_name
);
222 SAFE_FREE(module_path
);
223 SAFE_FREE(module_name
);
227 /*****************************************************************
228 Allow VFS modules to extend files_struct with VFS-specific state.
229 This will be ok for small numbers of extensions, but might need to
230 be refactored if it becomes more widely used.
231 ******************************************************************/
233 #define EXT_DATA_AREA(e) ((uint8 *)(e) + sizeof(struct vfs_fsp_data))
235 void *vfs_add_fsp_extension_notype(vfs_handle_struct
*handle
,
236 files_struct
*fsp
, size_t ext_size
,
237 void (*destroy_fn
)(void *p_data
))
239 struct vfs_fsp_data
*ext
;
242 /* Prevent VFS modules adding multiple extensions. */
243 if ((ext_data
= vfs_fetch_fsp_extension(handle
, fsp
))) {
247 ext
= (struct vfs_fsp_data
*)TALLOC_ZERO(
248 handle
->conn
, sizeof(struct vfs_fsp_data
) + ext_size
);
254 ext
->next
= fsp
->vfs_extension
;
255 ext
->destroy
= destroy_fn
;
256 fsp
->vfs_extension
= ext
;
257 return EXT_DATA_AREA(ext
);
260 void vfs_remove_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
262 struct vfs_fsp_data
*curr
;
263 struct vfs_fsp_data
*prev
;
265 for (curr
= fsp
->vfs_extension
, prev
= NULL
;
267 prev
= curr
, curr
= curr
->next
) {
268 if (curr
->owner
== handle
) {
270 prev
->next
= curr
->next
;
272 fsp
->vfs_extension
= curr
->next
;
275 curr
->destroy(EXT_DATA_AREA(curr
));
283 void *vfs_memctx_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
285 struct vfs_fsp_data
*head
;
287 for (head
= fsp
->vfs_extension
; head
; head
= head
->next
) {
288 if (head
->owner
== handle
) {
296 void *vfs_fetch_fsp_extension(vfs_handle_struct
*handle
, files_struct
*fsp
)
298 struct vfs_fsp_data
*head
;
300 head
= (struct vfs_fsp_data
*)vfs_memctx_fsp_extension(handle
, fsp
);
302 return EXT_DATA_AREA(head
);
310 /*****************************************************************
312 ******************************************************************/
314 bool smbd_vfs_init(connection_struct
*conn
)
316 const char **vfs_objects
;
320 /* Normal share - initialise with disk access functions */
321 vfs_init_default(conn
);
322 vfs_objects
= lp_vfs_objects(SNUM(conn
));
324 /* Override VFS functions if 'vfs object' was not specified*/
325 if (!vfs_objects
|| !vfs_objects
[0])
328 for (i
=0; vfs_objects
[i
] ;) {
332 for (j
=i
-1; j
>= 0; j
--) {
333 if (!vfs_init_custom(conn
, vfs_objects
[j
])) {
334 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects
[j
]));
341 /*******************************************************************
342 Check if directory exists.
343 ********************************************************************/
345 bool vfs_directory_exist(connection_struct
*conn
, const char *dname
, SMB_STRUCT_STAT
*st
)
353 if (SMB_VFS_STAT(conn
,dname
,st
) != 0)
356 ret
= S_ISDIR(st
->st_ex_mode
);
363 /*******************************************************************
364 Check if an object exists in the vfs.
365 ********************************************************************/
367 bool vfs_object_exist(connection_struct
*conn
,const char *fname
,SMB_STRUCT_STAT
*sbuf
)
376 if (SMB_VFS_STAT(conn
,fname
,sbuf
) == -1)
381 /*******************************************************************
382 Check if a file exists in the vfs.
383 ********************************************************************/
385 NTSTATUS
vfs_file_exist(connection_struct
*conn
, struct smb_filename
*smb_fname
)
390 status
= get_full_smb_filename(talloc_tos(), smb_fname
, &fname
);
391 if (!NT_STATUS_IS_OK(status
)) {
395 status
= NT_STATUS_OBJECT_NAME_NOT_FOUND
;
396 if (SMB_VFS_STAT(conn
, fname
, &smb_fname
->st
) == -1) {
400 /* Only return OK if stat was successful and S_ISREG */
401 if (S_ISREG(smb_fname
->st
.st_ex_mode
)) {
402 status
= NT_STATUS_OK
;
409 /****************************************************************************
410 Read data from fsp on the vfs. (note: EINTR re-read differs from vfs_write_data)
411 ****************************************************************************/
413 ssize_t
vfs_read_data(files_struct
*fsp
, char *buf
, size_t byte_count
)
417 while (total
< byte_count
)
419 ssize_t ret
= SMB_VFS_READ(fsp
, buf
+ total
,
422 if (ret
== 0) return total
;
431 return (ssize_t
)total
;
434 ssize_t
vfs_pread_data(files_struct
*fsp
, char *buf
,
435 size_t byte_count
, SMB_OFF_T offset
)
439 while (total
< byte_count
)
441 ssize_t ret
= SMB_VFS_PREAD(fsp
, buf
+ total
,
442 byte_count
- total
, offset
+ total
);
444 if (ret
== 0) return total
;
453 return (ssize_t
)total
;
456 /****************************************************************************
457 Write data to a fd on the vfs.
458 ****************************************************************************/
460 ssize_t
vfs_write_data(struct smb_request
*req
,
468 if (req
&& req
->unread_bytes
) {
469 SMB_ASSERT(req
->unread_bytes
== N
);
470 /* VFS_RECVFILE must drain the socket
471 * before returning. */
472 req
->unread_bytes
= 0;
473 return SMB_VFS_RECVFILE(smbd_server_fd(),
480 ret
= SMB_VFS_WRITE(fsp
, buffer
+ total
, N
- total
);
489 return (ssize_t
)total
;
492 ssize_t
vfs_pwrite_data(struct smb_request
*req
,
501 if (req
&& req
->unread_bytes
) {
502 SMB_ASSERT(req
->unread_bytes
== N
);
503 /* VFS_RECVFILE must drain the socket
504 * before returning. */
505 req
->unread_bytes
= 0;
506 return SMB_VFS_RECVFILE(smbd_server_fd(),
513 ret
= SMB_VFS_PWRITE(fsp
, buffer
+ total
, N
- total
,
523 return (ssize_t
)total
;
525 /****************************************************************************
526 An allocate file space call using the vfs interface.
527 Allocates space for a file from a filedescriptor.
528 Returns 0 on success, -1 on failure.
529 ****************************************************************************/
531 int vfs_allocate_file_space(files_struct
*fsp
, uint64_t len
)
535 connection_struct
*conn
= fsp
->conn
;
536 uint64_t space_avail
;
537 uint64_t bsize
,dfree
,dsize
;
540 * Actually try and commit the space on disk....
543 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n", fsp
->fsp_name
, (double)len
));
545 if (((SMB_OFF_T
)len
) < 0) {
546 DEBUG(0,("vfs_allocate_file_space: %s negative len requested.\n", fsp
->fsp_name
));
551 ret
= SMB_VFS_FSTAT(fsp
, &st
);
555 if (len
== (uint64_t)st
.st_ex_size
)
558 if (len
< (uint64_t)st
.st_ex_size
) {
559 /* Shrink - use ftruncate. */
561 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current size %.0f\n",
562 fsp
->fsp_name
, (double)st
.st_ex_size
));
564 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
566 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
567 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, (SMB_OFF_T
)len
)) != -1) {
568 set_filelen_write_cache(fsp
, len
);
571 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_SHRINK
);
576 /* Grow - we need to test if we have enough space. */
578 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
579 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_ALLOC_GROW
);
581 if (!lp_strict_allocate(SNUM(fsp
->conn
)))
584 len
-= st
.st_ex_size
;
585 len
/= 1024; /* Len is now number of 1k blocks needed. */
586 space_avail
= get_dfree_info(conn
,fsp
->fsp_name
,False
,&bsize
,&dfree
,&dsize
);
587 if (space_avail
== (uint64_t)-1) {
591 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
592 fsp
->fsp_name
, (double)st
.st_ex_size
, (double)len
, (double)space_avail
));
594 if (len
> space_avail
) {
602 /****************************************************************************
603 A vfs set_filelen call.
604 set the length of a file from a filedescriptor.
605 Returns 0 on success, -1 on failure.
606 ****************************************************************************/
608 int vfs_set_filelen(files_struct
*fsp
, SMB_OFF_T len
)
612 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
614 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp
->fsp_name
, (double)len
));
615 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
616 if ((ret
= SMB_VFS_FTRUNCATE(fsp
, len
)) != -1) {
617 set_filelen_write_cache(fsp
, len
);
618 notify_fname(fsp
->conn
, NOTIFY_ACTION_MODIFIED
,
619 FILE_NOTIFY_CHANGE_SIZE
620 | FILE_NOTIFY_CHANGE_ATTRIBUTES
,
624 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_SET_FILE_LEN
);
629 /****************************************************************************
630 A vfs fill sparse call.
631 Writes zeros from the end of file to len, if len is greater than EOF.
632 Used only by strict_sync.
633 Returns 0 on success, -1 on failure.
634 ****************************************************************************/
636 #define SPARSE_BUF_WRITE_SIZE (32*1024)
638 int vfs_fill_sparse(files_struct
*fsp
, SMB_OFF_T len
)
647 ret
= SMB_VFS_FSTAT(fsp
, &st
);
652 if (len
<= st
.st_ex_size
) {
656 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to len %.0f (%.0f bytes)\n",
657 fsp
->fsp_name
, (double)st
.st_ex_size
, (double)len
, (double)(len
- st
.st_ex_size
)));
659 contend_level2_oplocks_begin(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
661 flush_write_cache(fsp
, SIZECHANGE_FLUSH
);
664 sparse_buf
= SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE
);
672 offset
= st
.st_ex_size
;
673 num_to_write
= len
- st
.st_ex_size
;
676 while (total
< num_to_write
) {
677 size_t curr_write_size
= MIN(SPARSE_BUF_WRITE_SIZE
, (num_to_write
- total
));
679 pwrite_ret
= SMB_VFS_PWRITE(fsp
, sparse_buf
, curr_write_size
, offset
+ total
);
680 if (pwrite_ret
== -1) {
681 DEBUG(10,("vfs_fill_sparse: SMB_VFS_PWRITE for file %s failed with error %s\n",
682 fsp
->fsp_name
, strerror(errno
) ));
686 if (pwrite_ret
== 0) {
694 set_filelen_write_cache(fsp
, len
);
698 contend_level2_oplocks_end(fsp
, LEVEL2_CONTEND_FILL_SPARSE
);
702 /****************************************************************************
703 Transfer some data (n bytes) between two file_struct's.
704 ****************************************************************************/
706 static ssize_t
vfs_read_fn(void *file
, void *buf
, size_t len
)
708 struct files_struct
*fsp
= (struct files_struct
*)file
;
710 return SMB_VFS_READ(fsp
, buf
, len
);
713 static ssize_t
vfs_write_fn(void *file
, const void *buf
, size_t len
)
715 struct files_struct
*fsp
= (struct files_struct
*)file
;
717 return SMB_VFS_WRITE(fsp
, buf
, len
);
720 SMB_OFF_T
vfs_transfer_file(files_struct
*in
, files_struct
*out
, SMB_OFF_T n
)
722 return transfer_file_internal((void *)in
, (void *)out
, n
,
723 vfs_read_fn
, vfs_write_fn
);
726 /*******************************************************************
727 A vfs_readdir wrapper which just returns the file name.
728 ********************************************************************/
730 char *vfs_readdirname(connection_struct
*conn
, void *p
, SMB_STRUCT_STAT
*sbuf
)
732 SMB_STRUCT_DIRENT
*ptr
= NULL
;
738 ptr
= SMB_VFS_READDIR(conn
, (DIR *)p
, sbuf
);
749 #ifdef HAVE_BROKEN_READDIR_NAME
750 /* using /usr/ucb/cc is BAD */
757 /*******************************************************************
758 A wrapper for vfs_chdir().
759 ********************************************************************/
761 int vfs_ChDir(connection_struct
*conn
, const char *path
)
766 LastDir
= SMB_STRDUP("");
769 if (strcsequal(path
,"."))
772 if (*path
== '/' && strcsequal(LastDir
,path
))
775 DEBUG(4,("vfs_ChDir to %s\n",path
));
777 res
= SMB_VFS_CHDIR(conn
,path
);
780 LastDir
= SMB_STRDUP(path
);
785 /*******************************************************************
786 Return the absolute current directory path - given a UNIX pathname.
787 Note that this path is returned in DOS format, not UNIX
788 format. Note this can be called with conn == NULL.
789 ********************************************************************/
791 char *vfs_GetWd(TALLOC_CTX
*ctx
, connection_struct
*conn
)
794 SMB_STRUCT_STAT st
, st2
;
796 DATA_BLOB cache_value
;
801 if (!lp_getwd_cache()) {
805 SET_STAT_INVALID(st
);
807 if (SMB_VFS_STAT(conn
, ".",&st
) == -1) {
809 * Known to fail for root: the directory may be NFS-mounted
810 * and exported with root_squash (so has no root access).
812 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
813 "(NFS problem ?)\n", strerror(errno
) ));
817 key
= vfs_file_id_from_sbuf(conn
, &st
);
819 if (!memcache_lookup(smbd_memcache(), GETWD_CACHE
,
820 data_blob_const(&key
, sizeof(key
)),
825 SMB_ASSERT((cache_value
.length
> 0)
826 && (cache_value
.data
[cache_value
.length
-1] == '\0'));
828 if ((SMB_VFS_STAT(conn
, (char *)cache_value
.data
, &st2
) == 0)
829 && (st
.st_ex_dev
== st2
.st_ex_dev
) && (st
.st_ex_ino
== st2
.st_ex_ino
)
830 && (S_ISDIR(st
.st_ex_mode
))) {
834 result
= talloc_strdup(ctx
, (char *)cache_value
.data
);
835 if (result
== NULL
) {
844 * We don't have the information to hand so rely on traditional
845 * methods. The very slow getcwd, which spawns a process on some
846 * systems, or the not quite so bad getwd.
849 if (!SMB_VFS_GETWD(conn
,s
)) {
850 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
855 if (lp_getwd_cache() && VALID_STAT(st
)) {
856 key
= vfs_file_id_from_sbuf(conn
, &st
);
858 memcache_add(smbd_memcache(), GETWD_CACHE
,
859 data_blob_const(&key
, sizeof(key
)),
860 data_blob_const(s
, strlen(s
)+1));
863 result
= talloc_strdup(ctx
, s
);
864 if (result
== NULL
) {
870 /*******************************************************************
871 Reduce a file name, removing .. elements and checking that
872 it is below dir in the heirachy. This uses realpath.
873 ********************************************************************/
875 NTSTATUS
check_reduced_name(connection_struct
*conn
, const char *fname
)
877 #ifdef REALPATH_TAKES_NULL
878 bool free_resolved_name
= True
;
880 char resolved_name_buf
[PATH_MAX
+1];
881 bool free_resolved_name
= False
;
883 char *resolved_name
= NULL
;
886 DEBUG(3,("reduce_name [%s] [%s]\n", fname
, conn
->connectpath
));
888 #ifdef REALPATH_TAKES_NULL
889 resolved_name
= SMB_VFS_REALPATH(conn
,fname
,NULL
);
891 resolved_name
= SMB_VFS_REALPATH(conn
,fname
,resolved_name_buf
);
894 if (!resolved_name
) {
897 DEBUG(3,("reduce_name: Component not a directory in getting realpath for %s\n", fname
));
898 return map_nt_error_from_unix(errno
);
901 TALLOC_CTX
*ctx
= talloc_tos();
902 char *tmp_fname
= NULL
;
903 char *last_component
= NULL
;
904 /* Last component didn't exist. Remove it and try and canonicalise the directory. */
906 tmp_fname
= talloc_strdup(ctx
, fname
);
908 return NT_STATUS_NO_MEMORY
;
910 p
= strrchr_m(tmp_fname
, '/');
915 last_component
= tmp_fname
;
916 tmp_fname
= talloc_strdup(ctx
,
919 return NT_STATUS_NO_MEMORY
;
923 #ifdef REALPATH_TAKES_NULL
924 resolved_name
= SMB_VFS_REALPATH(conn
,tmp_fname
,NULL
);
926 resolved_name
= SMB_VFS_REALPATH(conn
,tmp_fname
,resolved_name_buf
);
928 if (!resolved_name
) {
929 DEBUG(3,("reduce_name: couldn't get realpath for %s\n", fname
));
930 return map_nt_error_from_unix(errno
);
932 tmp_fname
= talloc_asprintf(ctx
,
937 return NT_STATUS_NO_MEMORY
;
939 #ifdef REALPATH_TAKES_NULL
940 SAFE_FREE(resolved_name
);
941 resolved_name
= SMB_STRDUP(tmp_fname
);
942 if (!resolved_name
) {
943 DEBUG(0,("reduce_name: malloc fail for %s\n", tmp_fname
));
944 return NT_STATUS_NO_MEMORY
;
947 safe_strcpy(resolved_name_buf
, tmp_fname
, PATH_MAX
);
948 resolved_name
= resolved_name_buf
;
953 DEBUG(1,("reduce_name: couldn't get realpath for %s\n", fname
));
954 return map_nt_error_from_unix(errno
);
958 DEBUG(10,("reduce_name realpath [%s] -> [%s]\n", fname
, resolved_name
));
960 if (*resolved_name
!= '/') {
961 DEBUG(0,("reduce_name: realpath doesn't return absolute paths !\n"));
962 if (free_resolved_name
) {
963 SAFE_FREE(resolved_name
);
965 return NT_STATUS_OBJECT_NAME_INVALID
;
968 /* Check for widelinks allowed. */
969 if (!lp_widelinks(SNUM(conn
))) {
970 const char *conn_rootdir
;
972 conn_rootdir
= SMB_VFS_CONNECTPATH(conn
, fname
);
973 if (conn_rootdir
== NULL
) {
974 DEBUG(2, ("check_reduced_name: Could not get conn_rootdir\n"));
975 if (free_resolved_name
) {
976 SAFE_FREE(resolved_name
);
978 return NT_STATUS_ACCESS_DENIED
;
981 if (strncmp(conn_rootdir
, resolved_name
,
982 strlen(conn_rootdir
)) != 0) {
983 DEBUG(2, ("reduce_name: Bad access attempt: %s is "
984 "a symlink outside the share path",
986 if (free_resolved_name
) {
987 SAFE_FREE(resolved_name
);
989 return NT_STATUS_ACCESS_DENIED
;
993 /* Check if we are allowing users to follow symlinks */
994 /* Patch from David Clerc <David.Clerc@cui.unige.ch>
995 University of Geneva */
998 if (!lp_symlinks(SNUM(conn
))) {
999 SMB_STRUCT_STAT statbuf
;
1000 if ( (SMB_VFS_LSTAT(conn
,fname
,&statbuf
) != -1) &&
1001 (S_ISLNK(statbuf
.st_ex_mode
)) ) {
1002 if (free_resolved_name
) {
1003 SAFE_FREE(resolved_name
);
1005 DEBUG(3,("reduce_name: denied: file path name %s is a symlink\n",resolved_name
));
1006 return NT_STATUS_ACCESS_DENIED
;
1011 DEBUG(3,("reduce_name: %s reduced to %s\n", fname
, resolved_name
));
1012 if (free_resolved_name
) {
1013 SAFE_FREE(resolved_name
);
1015 return NT_STATUS_OK
;