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.
28 #define DBGC_CLASS DBGC_VFS
32 struct vfs_init_function_entry {
34 const vfs_op_tuple *vfs_op_tuples;
35 struct vfs_init_function_entry *prev, *next;
38 static struct vfs_init_function_entry *backends = NULL;
40 /****************************************************************************
41 maintain the list of available backends
42 ****************************************************************************/
44 static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
46 struct vfs_init_function_entry *entry = backends;
48 DEBUG(10, ("vfs_find_backend_entry called for %s\n", name));
51 if (strcmp(entry->name, name)==0) return entry;
58 NTSTATUS smb_register_vfs(int version, const char *name, const vfs_op_tuple *vfs_op_tuples)
60 struct vfs_init_function_entry *entry = backends;
62 if ((version != SMB_VFS_INTERFACE_VERSION)) {
63 DEBUG(0, ("Failed to register vfs module.\n"
64 "The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
65 "current SMB_VFS_INTERFACE_VERSION is %d.\n"
66 "Please recompile against the current Samba Version!\n",
67 version, SMB_VFS_INTERFACE_VERSION));
68 return NT_STATUS_OBJECT_TYPE_MISMATCH;
71 if (!name || !name[0] || !vfs_op_tuples) {
72 DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
73 return NT_STATUS_INVALID_PARAMETER;
76 if (vfs_find_backend_entry(name)) {
77 DEBUG(0,("VFS module %s already loaded!\n", name));
78 return NT_STATUS_OBJECT_NAME_COLLISION;
81 entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
82 entry->name = smb_xstrdup(name);
83 entry->vfs_op_tuples = vfs_op_tuples;
85 DLIST_ADD(backends, entry);
86 DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
90 /****************************************************************************
91 initialise default vfs hooks
92 ****************************************************************************/
94 static void vfs_init_default(connection_struct *conn)
96 DEBUG(3, ("Initialising default vfs hooks\n"));
97 vfs_init_custom(conn, DEFAULT_VFS_MODULE_NAME);
100 /****************************************************************************
101 initialise custom vfs hooks
102 ****************************************************************************/
104 static inline void vfs_set_operation(struct vfs_ops * vfs, vfs_op_type which,
105 struct vfs_handle_struct * handle, void * op)
107 ((struct vfs_handle_struct **)&vfs->handles)[which] = handle;
108 ((void **)(void *)&vfs->ops)[which] = op;
111 bool vfs_init_custom(connection_struct *conn, const char *vfs_object)
113 const vfs_op_tuple *ops;
114 char *module_path = NULL;
115 char *module_name = NULL;
116 char *module_param = NULL, *p;
118 vfs_handle_struct *handle;
119 const struct vfs_init_function_entry *entry;
121 if (!conn||!vfs_object||!vfs_object[0]) {
122 DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
130 DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
132 module_path = smb_xstrdup(vfs_object);
134 p = strchr_m(module_path, ':');
139 trim_char(module_param, ' ', ' ');
142 trim_char(module_path, ' ', ' ');
144 module_name = smb_xstrdup(module_path);
146 if ((module_name[0] == '/') &&
147 (strcmp(module_path, DEFAULT_VFS_MODULE_NAME) != 0)) {
150 * Extract the module name from the path. Just use the base
151 * name of the last path component.
154 SAFE_FREE(module_name);
155 module_name = smb_xstrdup(strrchr_m(module_path, '/')+1);
157 p = strchr_m(module_name, '.');
164 /* First, try to load the module with the new module system */
165 if((entry = vfs_find_backend_entry(module_name)) ||
166 (NT_STATUS_IS_OK(smb_probe_module("vfs", module_path)) &&
167 (entry = vfs_find_backend_entry(module_name)))) {
169 DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
171 if ((ops = entry->vfs_op_tuples) == NULL) {
172 DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object));
176 DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
180 handle = TALLOC_ZERO_P(conn->mem_ctx,vfs_handle_struct);
182 DEBUG(0,("TALLOC_ZERO() failed!\n"));
185 memcpy(&handle->vfs_next, &conn->vfs, sizeof(struct vfs_ops));
188 handle->param = talloc_strdup(conn->mem_ctx, module_param);
190 DLIST_ADD(conn->vfs_handles, handle);
192 for(i=0; ops[i].op != NULL; i++) {
193 DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
194 if(ops[i].layer == SMB_VFS_LAYER_OPAQUE) {
195 /* If this operation was already made opaque by different module, it
196 * will be overridden here.
198 DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
199 vfs_set_operation(&conn->vfs_opaque, ops[i].type, handle, ops[i].op);
201 /* Change current VFS disposition*/
202 DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
203 vfs_set_operation(&conn->vfs, ops[i].type, handle, ops[i].op);
206 SAFE_FREE(module_path);
207 SAFE_FREE(module_name);
211 SAFE_FREE(module_path);
212 SAFE_FREE(module_name);
216 /*****************************************************************
217 Allow VFS modules to extend files_struct with VFS-specific state.
218 This will be ok for small numbers of extensions, but might need to
219 be refactored if it becomes more widely used.
220 ******************************************************************/
222 #define EXT_DATA_AREA(e) ((uint8 *)(e) + sizeof(struct vfs_fsp_data))
224 void *vfs_add_fsp_extension_notype(vfs_handle_struct *handle, files_struct *fsp, size_t ext_size)
226 struct vfs_fsp_data *ext;
229 /* Prevent VFS modules adding multiple extensions. */
230 if ((ext_data = vfs_fetch_fsp_extension(handle, fsp))) {
234 ext = (struct vfs_fsp_data *)TALLOC_ZERO(
235 handle->conn->mem_ctx, sizeof(struct vfs_fsp_data) + ext_size);
241 ext->next = fsp->vfs_extension;
242 fsp->vfs_extension = ext;
243 return EXT_DATA_AREA(ext);
246 void vfs_remove_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
248 struct vfs_fsp_data *curr;
249 struct vfs_fsp_data *prev;
251 for (curr = fsp->vfs_extension, prev = NULL;
253 prev = curr, curr = curr->next) {
254 if (curr->owner == handle) {
256 prev->next = curr->next;
258 fsp->vfs_extension = curr->next;
266 void *vfs_memctx_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
268 struct vfs_fsp_data *head;
270 for (head = fsp->vfs_extension; head; head = head->next) {
271 if (head->owner == handle) {
279 void *vfs_fetch_fsp_extension(vfs_handle_struct *handle, files_struct *fsp)
281 struct vfs_fsp_data *head;
283 head = (struct vfs_fsp_data *)vfs_memctx_fsp_extension(handle, fsp);
285 return EXT_DATA_AREA(head);
293 /*****************************************************************
295 ******************************************************************/
297 bool smbd_vfs_init(connection_struct *conn)
299 const char **vfs_objects;
303 /* Normal share - initialise with disk access functions */
304 vfs_init_default(conn);
305 vfs_objects = lp_vfs_objects(SNUM(conn));
307 /* Override VFS functions if 'vfs object' was not specified*/
308 if (!vfs_objects || !vfs_objects[0])
311 for (i=0; vfs_objects[i] ;) {
315 for (j=i-1; j >= 0; j--) {
316 if (!vfs_init_custom(conn, vfs_objects[j])) {
317 DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
324 /*******************************************************************
325 Check if directory exists.
326 ********************************************************************/
328 bool vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st)
336 if (SMB_VFS_STAT(conn,dname,st) != 0)
339 ret = S_ISDIR(st->st_mode);
346 /*******************************************************************
347 Check if an object exists in the vfs.
348 ********************************************************************/
350 bool vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT *sbuf)
359 if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
364 /*******************************************************************
365 Check if a file exists in the vfs.
366 ********************************************************************/
368 bool vfs_file_exist(connection_struct *conn, const char *fname,SMB_STRUCT_STAT *sbuf)
377 if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
379 return(S_ISREG(sbuf->st_mode));
382 /****************************************************************************
383 Read data from fsp on the vfs. (note: EINTR re-read differs from vfs_write_data)
384 ****************************************************************************/
386 ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count)
390 while (total < byte_count)
392 ssize_t ret = SMB_VFS_READ(fsp, fsp->fh->fd, buf + total,
395 if (ret == 0) return total;
404 return (ssize_t)total;
407 ssize_t vfs_pread_data(files_struct *fsp, char *buf,
408 size_t byte_count, SMB_OFF_T offset)
412 while (total < byte_count)
414 ssize_t ret = SMB_VFS_PREAD(fsp, buf + total,
415 byte_count - total, offset + total);
417 if (ret == 0) return total;
426 return (ssize_t)total;
429 /****************************************************************************
430 Write data to a fd on the vfs.
431 ****************************************************************************/
433 ssize_t vfs_write_data(struct smb_request *req,
441 if (req && req->unread_bytes) {
442 SMB_ASSERT(req->unread_bytes == N);
443 /* VFS_RECVFILE must drain the socket
444 * before returning. */
445 req->unread_bytes = 0;
446 return SMB_VFS_RECVFILE(smbd_server_fd(),
454 ret = SMB_VFS_WRITE(fsp,fsp->fh->fd,buffer + total,N - total);
463 return (ssize_t)total;
466 ssize_t vfs_pwrite_data(struct smb_request *req,
475 if (req && req->unread_bytes) {
476 SMB_ASSERT(req->unread_bytes == N);
477 /* VFS_RECVFILE must drain the socket
478 * before returning. */
479 req->unread_bytes = 0;
480 return SMB_VFS_RECVFILE(smbd_server_fd(),
488 ret = SMB_VFS_PWRITE(fsp, buffer + total, N - total,
498 return (ssize_t)total;
500 /****************************************************************************
501 An allocate file space call using the vfs interface.
502 Allocates space for a file from a filedescriptor.
503 Returns 0 on success, -1 on failure.
504 ****************************************************************************/
506 int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
510 connection_struct *conn = fsp->conn;
511 SMB_BIG_UINT space_avail;
512 SMB_BIG_UINT bsize,dfree,dsize;
514 release_level_2_oplocks_on_change(fsp);
517 * Actually try and commit the space on disk....
520 DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n", fsp->fsp_name, (double)len ));
522 if (((SMB_OFF_T)len) < 0) {
523 DEBUG(0,("vfs_allocate_file_space: %s negative len requested.\n", fsp->fsp_name ));
528 ret = SMB_VFS_FSTAT(fsp, &st);
532 if (len == (SMB_BIG_UINT)st.st_size)
535 if (len < (SMB_BIG_UINT)st.st_size) {
536 /* Shrink - use ftruncate. */
538 DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current size %.0f\n",
539 fsp->fsp_name, (double)st.st_size ));
541 flush_write_cache(fsp, SIZECHANGE_FLUSH);
542 if ((ret = SMB_VFS_FTRUNCATE(fsp, (SMB_OFF_T)len)) != -1) {
543 set_filelen_write_cache(fsp, len);
548 /* Grow - we need to test if we have enough space. */
550 if (!lp_strict_allocate(SNUM(fsp->conn)))
554 len /= 1024; /* Len is now number of 1k blocks needed. */
555 space_avail = get_dfree_info(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
556 if (space_avail == (SMB_BIG_UINT)-1) {
560 DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
561 fsp->fsp_name, (double)st.st_size, (double)len, (double)space_avail ));
563 if (len > space_avail) {
571 /****************************************************************************
572 A vfs set_filelen call.
573 set the length of a file from a filedescriptor.
574 Returns 0 on success, -1 on failure.
575 ****************************************************************************/
577 int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len)
581 release_level_2_oplocks_on_change(fsp);
582 DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp->fsp_name, (double)len));
583 flush_write_cache(fsp, SIZECHANGE_FLUSH);
584 if ((ret = SMB_VFS_FTRUNCATE(fsp, len)) != -1) {
585 set_filelen_write_cache(fsp, len);
586 notify_fname(fsp->conn, NOTIFY_ACTION_MODIFIED,
587 FILE_NOTIFY_CHANGE_SIZE
588 | FILE_NOTIFY_CHANGE_ATTRIBUTES,
595 /****************************************************************************
596 A vfs fill sparse call.
597 Writes zeros from the end of file to len, if len is greater than EOF.
598 Used only by strict_sync.
599 Returns 0 on success, -1 on failure.
600 ****************************************************************************/
602 static char *sparse_buf;
603 #define SPARSE_BUF_WRITE_SIZE (32*1024)
605 int vfs_fill_sparse(files_struct *fsp, SMB_OFF_T len)
614 release_level_2_oplocks_on_change(fsp);
615 ret = SMB_VFS_FSTAT(fsp, &st);
620 if (len <= st.st_size) {
624 DEBUG(10,("vfs_fill_sparse: write zeros in file %s from len %.0f to len %.0f (%.0f bytes)\n",
625 fsp->fsp_name, (double)st.st_size, (double)len, (double)(len - st.st_size)));
627 flush_write_cache(fsp, SIZECHANGE_FLUSH);
630 sparse_buf = SMB_CALLOC_ARRAY(char, SPARSE_BUF_WRITE_SIZE);
638 num_to_write = len - st.st_size;
641 while (total < num_to_write) {
642 size_t curr_write_size = MIN(SPARSE_BUF_WRITE_SIZE, (num_to_write - total));
644 pwrite_ret = SMB_VFS_PWRITE(fsp, sparse_buf, curr_write_size, offset + total);
645 if (pwrite_ret == -1) {
646 DEBUG(10,("vfs_fill_sparse: SMB_VFS_PWRITE for file %s failed with error %s\n",
647 fsp->fsp_name, strerror(errno) ));
650 if (pwrite_ret == 0) {
657 set_filelen_write_cache(fsp, len);
661 /****************************************************************************
662 Transfer some data (n bytes) between two file_struct's.
663 ****************************************************************************/
665 static files_struct *in_fsp;
666 static files_struct *out_fsp;
668 static ssize_t read_fn(int fd, void *buf, size_t len)
670 return SMB_VFS_READ(in_fsp, fd, buf, len);
673 static ssize_t write_fn(int fd, const void *buf, size_t len)
675 return SMB_VFS_WRITE(out_fsp, fd, buf, len);
678 SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
683 return transfer_file_internal(in_fsp->fh->fd, out_fsp->fh->fd, n, read_fn, write_fn);
686 /*******************************************************************
687 A vfs_readdir wrapper which just returns the file name.
688 ********************************************************************/
690 char *vfs_readdirname(connection_struct *conn, void *p)
692 SMB_STRUCT_DIRENT *ptr= NULL;
698 ptr = SMB_VFS_READDIR(conn, (DIR *)p);
709 #ifdef HAVE_BROKEN_READDIR_NAME
710 /* using /usr/ucb/cc is BAD */
717 /*******************************************************************
718 A wrapper for vfs_chdir().
719 ********************************************************************/
721 int vfs_ChDir(connection_struct *conn, const char *path)
724 static char *LastDir = NULL;
727 LastDir = SMB_STRDUP("");
730 if (strcsequal(path,"."))
733 if (*path == '/' && strcsequal(LastDir,path))
736 DEBUG(4,("vfs_ChDir to %s\n",path));
738 res = SMB_VFS_CHDIR(conn,path);
741 LastDir = SMB_STRDUP(path);
746 /*******************************************************************
747 Return the absolute current directory path - given a UNIX pathname.
748 Note that this path is returned in DOS format, not UNIX
749 format. Note this can be called with conn == NULL.
750 ********************************************************************/
752 struct getwd_cache_key {
757 char *vfs_GetWd(TALLOC_CTX *ctx, connection_struct *conn)
760 SMB_STRUCT_STAT st, st2;
762 DATA_BLOB cache_value;
763 struct getwd_cache_key key;
767 if (!lp_getwd_cache()) {
771 SET_STAT_INVALID(st);
773 if (SMB_VFS_STAT(conn, ".",&st) == -1) {
775 * Known to fail for root: the directory may be NFS-mounted
776 * and exported with root_squash (so has no root access).
778 DEBUG(1,("vfs_GetWd: couldn't stat \".\" error %s "
779 "(NFS problem ?)\n", strerror(errno) ));
783 ZERO_STRUCT(key); /* unlikely, but possible padding */
787 if (!memcache_lookup(smbd_memcache(), GETWD_CACHE,
788 data_blob_const(&key, sizeof(key)),
793 SMB_ASSERT((cache_value.length > 0)
794 && (cache_value.data[cache_value.length-1] == '\0'));
796 if ((SMB_VFS_STAT(conn, (char *)cache_value.data, &st2) == 0)
797 && (st.st_dev == st2.st_dev) && (st.st_ino == st2.st_ino)
798 && (S_ISDIR(st.st_mode))) {
802 result = talloc_strdup(ctx, (char *)cache_value.data);
803 if (result == NULL) {
812 * We don't have the information to hand so rely on traditional
813 * methods. The very slow getcwd, which spawns a process on some
814 * systems, or the not quite so bad getwd.
817 if (!SMB_VFS_GETWD(conn,s)) {
818 DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
823 if (lp_getwd_cache() && VALID_STAT(st)) {
824 ZERO_STRUCT(key); /* unlikely, but possible padding */
828 memcache_add(smbd_memcache(), GETWD_CACHE,
829 data_blob_const(&key, sizeof(key)),
830 data_blob_const(s, strlen(s)+1));
833 result = talloc_strdup(ctx, s);
834 if (result == NULL) {
840 /*******************************************************************
841 Reduce a file name, removing .. elements and checking that
842 it is below dir in the heirachy. This uses realpath.
843 ********************************************************************/
845 NTSTATUS check_reduced_name(connection_struct *conn, const char *fname)
847 #ifdef REALPATH_TAKES_NULL
848 bool free_resolved_name = True;
850 char resolved_name_buf[PATH_MAX+1];
851 bool free_resolved_name = False;
853 char *resolved_name = NULL;
854 size_t con_path_len = strlen(conn->connectpath);
857 DEBUG(3,("reduce_name [%s] [%s]\n", fname, conn->connectpath));
859 #ifdef REALPATH_TAKES_NULL
860 resolved_name = SMB_VFS_REALPATH(conn,fname,NULL);
862 resolved_name = SMB_VFS_REALPATH(conn,fname,resolved_name_buf);
865 if (!resolved_name) {
868 DEBUG(3,("reduce_name: Component not a directory in getting realpath for %s\n", fname));
869 return map_nt_error_from_unix(errno);
872 TALLOC_CTX *tmp_ctx = talloc_stackframe();
873 char *tmp_fname = NULL;
874 char *last_component = NULL;
875 /* Last component didn't exist. Remove it and try and canonicalise the directory. */
877 tmp_fname = talloc_strdup(tmp_ctx, fname);
879 TALLOC_FREE(tmp_ctx);
880 return NT_STATUS_NO_MEMORY;
882 p = strrchr_m(tmp_fname, '/');
887 last_component = tmp_fname;
888 tmp_fname = talloc_strdup(tmp_ctx,
891 TALLOC_FREE(tmp_ctx);
892 return NT_STATUS_NO_MEMORY;
896 #ifdef REALPATH_TAKES_NULL
897 resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,NULL);
899 resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,resolved_name_buf);
901 if (!resolved_name) {
902 DEBUG(3,("reduce_name: couldn't get realpath for %s\n", fname));
903 TALLOC_FREE(tmp_ctx);
904 return map_nt_error_from_unix(errno);
906 tmp_fname = talloc_asprintf(tmp_ctx,
911 TALLOC_FREE(tmp_ctx);
912 return NT_STATUS_NO_MEMORY;
914 #ifdef REALPATH_TAKES_NULL
915 SAFE_FREE(resolved_name);
916 resolved_name = SMB_STRDUP(tmp_fname);
917 if (!resolved_name) {
918 DEBUG(0,("reduce_name: malloc fail for %s\n", tmp_fname));
919 return NT_STATUS_NO_MEMORY;
922 safe_strcpy(resolved_name_buf, tmp_fname, PATH_MAX);
923 resolved_name = resolved_name_buf;
925 TALLOC_FREE(tmp_ctx);
929 DEBUG(1,("reduce_name: couldn't get realpath for %s\n", fname));
930 return map_nt_error_from_unix(errno);
934 DEBUG(10,("reduce_name realpath [%s] -> [%s]\n", fname, resolved_name));
936 if (*resolved_name != '/') {
937 DEBUG(0,("reduce_name: realpath doesn't return absolute paths !\n"));
938 if (free_resolved_name) {
939 SAFE_FREE(resolved_name);
941 return NT_STATUS_OBJECT_NAME_INVALID;
944 /* Check for widelinks allowed. */
945 if (!lp_widelinks(SNUM(conn)) && (strncmp(conn->connectpath, resolved_name, con_path_len) != 0)) {
946 DEBUG(2, ("reduce_name: Bad access attempt: %s is a symlink outside the share path", fname));
947 if (free_resolved_name) {
948 SAFE_FREE(resolved_name);
950 return NT_STATUS_ACCESS_DENIED;
953 /* Check if we are allowing users to follow symlinks */
954 /* Patch from David Clerc <David.Clerc@cui.unige.ch>
955 University of Geneva */
958 if (!lp_symlinks(SNUM(conn))) {
959 SMB_STRUCT_STAT statbuf;
960 if ( (SMB_VFS_LSTAT(conn,fname,&statbuf) != -1) &&
961 (S_ISLNK(statbuf.st_mode)) ) {
962 if (free_resolved_name) {
963 SAFE_FREE(resolved_name);
965 DEBUG(3,("reduce_name: denied: file path name %s is a symlink\n",resolved_name));
966 return NT_STATUS_ACCESS_DENIED;
971 DEBUG(3,("reduce_name: %s reduced to %s\n", fname, resolved_name));
972 if (free_resolved_name) {
973 SAFE_FREE(resolved_name);