(vfs_setup_cwd): move directory test to separate function.
[midnight-commander.git] / lib / vfs / vfs.c
blob0ef6bd4edac0686b3a91c28f159c806fa6a9c0f7
1 /*
2 Virtual File System switch code
4 Copyright (C) 1995-2016
5 Free Software Foundation, Inc.
7 Written by: 1995 Miguel de Icaza
8 Jakub Jelinek, 1995
9 Pavel Machek, 1998
10 Slava Zanko <slavazanko@gmail.com>, 2013
12 This file is part of the Midnight Commander.
14 The Midnight Commander is free software: you can redistribute it
15 and/or modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation, either version 3 of the License,
17 or (at your option) any later version.
19 The Midnight Commander is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program. If not, see <http://www.gnu.org/licenses/>.
28 /**
29 * \file
30 * \brief Source: Virtual File System switch code
31 * \author Miguel de Icaza
32 * \author Jakub Jelinek
33 * \author Pavel Machek
34 * \date 1995, 1998
35 * \warning functions like extfs_lstat() have right to destroy any
36 * strings you pass to them. This is acutally ok as you g_strdup what
37 * you are passing to them, anyway; still, beware.
39 * Namespace: exports *many* functions with vfs_ prefix; exports
40 * parse_ls_lga and friends which do not have that prefix.
43 #include <config.h>
45 #include <errno.h>
46 #include <stdlib.h>
48 #include "lib/global.h"
49 #include "lib/strutil.h"
50 #include "lib/util.h"
51 #include "lib/widget.h" /* message() */
52 #include "lib/event.h"
54 #ifdef HAVE_CHARSET
55 #include "lib/charsets.h"
56 #endif
58 #include "vfs.h"
59 #include "utilvfs.h"
60 #include "gc.h"
62 /* TODO: move it to the separate .h */
63 extern struct dirent *mc_readdir_result;
64 extern GPtrArray *vfs__classes_list;
65 extern GString *vfs_str_buffer;
66 extern vfs_class *current_vfs;
68 /*** global variables ****************************************************************************/
70 GPtrArray *vfs__classes_list = NULL;
71 GString *vfs_str_buffer = NULL;
72 vfs_class *current_vfs = NULL;
74 /*** file scope macro definitions ****************************************************************/
76 #if defined(_AIX) && !defined(NAME_MAX)
77 #define NAME_MAX FILENAME_MAX
78 #endif
80 #define VFS_FIRST_HANDLE 100
82 #define ISSLASH(a) (a == '\0' || IS_PATH_SEP (a))
84 /*** file scope type declarations ****************************************************************/
86 struct vfs_openfile
88 int handle;
89 vfs_class *vclass;
90 void *fsinfo;
93 /*** file scope variables ************************************************************************/
95 /** They keep track of the current directory */
96 static vfs_path_t *current_path = NULL;
98 static GPtrArray *vfs_openfiles;
99 static long vfs_free_handle_list = -1;
101 /* --------------------------------------------------------------------------------------------- */
102 /*** file scope functions ************************************************************************/
103 /* --------------------------------------------------------------------------------------------- */
104 /* now used only by vfs_translate_path, but could be used in other vfs
105 * plugin to automatic detect encoding
106 * path - path to translate
107 * size - how many bytes from path translate
108 * defcnv - convertor, that is used as default, when path does not contain any
109 * #enc: subtring
110 * buffer - used to store result of translation
113 static estr_t
114 _vfs_translate_path (const char *path, int size, GIConv defcnv, GString * buffer)
116 estr_t state = ESTR_SUCCESS;
117 #ifdef HAVE_CHARSET
118 const char *semi;
120 if (size == 0)
121 return ESTR_SUCCESS;
123 size = (size > 0) ? size : (signed int) strlen (path);
125 /* try found /#enc: */
126 semi = g_strrstr_len (path, size, VFS_ENCODING_PREFIX);
127 if (semi != NULL && (semi == path || IS_PATH_SEP (semi[-1])))
129 char encoding[16];
130 const char *slash;
131 GIConv coder = INVALID_CONV;
132 int ms;
134 /* first must be translated part before #enc: */
135 ms = semi - path;
137 state = _vfs_translate_path (path, ms, defcnv, buffer);
139 if (state != ESTR_SUCCESS)
140 return state;
142 /* now can be translated part after #enc: */
143 semi += strlen (VFS_ENCODING_PREFIX); /* skip "#enc:" */
144 slash = strchr (semi, PATH_SEP);
145 /* ignore slashes after size; */
146 if (slash - path >= size)
147 slash = NULL;
149 ms = (slash != NULL) ? slash - semi : (int) strlen (semi);
150 ms = MIN ((unsigned int) ms, sizeof (encoding) - 1);
151 /* limit encoding size (ms) to path size (size) */
152 if (semi + ms > path + size)
153 ms = path + size - semi;
154 memcpy (encoding, semi, ms);
155 encoding[ms] = '\0';
157 if (is_supported_encoding (encoding))
158 coder = str_crt_conv_to (encoding);
160 if (coder != INVALID_CONV)
162 if (slash != NULL)
163 state = str_vfs_convert_to (coder, slash + 1, path + size - slash - 1, buffer);
164 str_close_conv (coder);
165 return state;
168 errno = EINVAL;
169 state = ESTR_FAILURE;
171 else
173 /* path can be translated whole at once */
174 state = str_vfs_convert_to (defcnv, path, size, buffer);
176 #else
177 (void) size;
178 (void) defcnv;
180 g_string_assign (buffer, path);
181 #endif /* HAVE_CHARSET */
183 return state;
186 /* --------------------------------------------------------------------------------------------- */
188 static struct vfs_openfile *
189 vfs_get_openfile (int handle)
191 struct vfs_openfile *h;
193 if (handle < VFS_FIRST_HANDLE || (guint) (handle - VFS_FIRST_HANDLE) >= vfs_openfiles->len)
194 return NULL;
196 h = (struct vfs_openfile *) g_ptr_array_index (vfs_openfiles, handle - VFS_FIRST_HANDLE);
197 if (h == NULL)
198 return NULL;
200 g_assert (h->handle == handle);
202 return h;
205 /* --------------------------------------------------------------------------------------------- */
207 static gboolean
208 vfs_test_current_dir (const vfs_path_t * vpath)
210 struct stat my_stat, my_stat2;
212 return (mc_global.vfs.cd_symlinks && mc_stat (vpath, &my_stat) == 0
213 && mc_stat (vfs_get_raw_current_dir (), &my_stat2) == 0
214 && my_stat.st_ino == my_stat2.st_ino && my_stat.st_dev == my_stat2.st_dev);
218 /* --------------------------------------------------------------------------------------------- */
219 /*** public functions ****************************************************************************/
220 /* --------------------------------------------------------------------------------------------- */
221 /** Free open file data for given file handle */
223 void
224 vfs_free_handle (int handle)
226 const int idx = handle - VFS_FIRST_HANDLE;
228 if (handle >= VFS_FIRST_HANDLE && (guint) idx < vfs_openfiles->len)
230 struct vfs_openfile *h;
232 h = (struct vfs_openfile *) g_ptr_array_index (vfs_openfiles, idx);
233 g_free (h);
234 g_ptr_array_index (vfs_openfiles, idx) = (void *) vfs_free_handle_list;
235 vfs_free_handle_list = idx;
240 /* --------------------------------------------------------------------------------------------- */
241 /** Find VFS class by file handle */
243 struct vfs_class *
244 vfs_class_find_by_handle (int handle, void **fsinfo)
246 struct vfs_openfile *h;
248 h = vfs_get_openfile (handle);
250 if (h == NULL)
251 return NULL;
253 if (fsinfo != NULL)
254 *fsinfo = h->fsinfo;
256 return h->vclass;
259 /* --------------------------------------------------------------------------------------------- */
262 * Create new VFS handle and put it to the list
266 vfs_new_handle (struct vfs_class *vclass, void *fsinfo)
268 struct vfs_openfile *h;
270 h = g_new (struct vfs_openfile, 1);
271 h->fsinfo = fsinfo;
272 h->vclass = vclass;
274 /* Allocate the first free handle */
275 h->handle = vfs_free_handle_list;
276 if (h->handle == -1)
278 /* No free allocated handles, allocate one */
279 h->handle = vfs_openfiles->len;
280 g_ptr_array_add (vfs_openfiles, h);
282 else
284 vfs_free_handle_list = (long) g_ptr_array_index (vfs_openfiles, vfs_free_handle_list);
285 g_ptr_array_index (vfs_openfiles, h->handle) = h;
288 h->handle += VFS_FIRST_HANDLE;
289 return h->handle;
292 /* --------------------------------------------------------------------------------------------- */
295 vfs_ferrno (struct vfs_class *vfs)
297 return vfs->ferrno ? (*vfs->ferrno) (vfs) : E_UNKNOWN;
298 /* Hope that error message is obscure enough ;-) */
301 /* --------------------------------------------------------------------------------------------- */
303 gboolean
304 vfs_register_class (struct vfs_class * vfs)
306 if (vfs->init != NULL) /* vfs has own initialization function */
307 if (!vfs->init (vfs)) /* but it failed */
308 return FALSE;
310 g_ptr_array_add (vfs__classes_list, vfs);
312 return TRUE;
315 /* --------------------------------------------------------------------------------------------- */
316 /** Strip known vfs suffixes from a filename (possible improvement: strip
317 * suffix from last path component).
318 * \return a malloced string which has to be freed.
321 char *
322 vfs_strip_suffix_from_filename (const char *filename)
324 char *semi, *p, *vfs_prefix;
326 if (filename == NULL)
327 vfs_die ("vfs_strip_suffix_from_path got NULL: impossible");
329 p = g_strdup (filename);
330 semi = g_strrstr (p, VFS_PATH_URL_DELIMITER);
331 if (semi == NULL)
332 return p;
334 *semi = '\0';
335 vfs_prefix = strrchr (p, PATH_SEP);
336 if (vfs_prefix == NULL)
338 *semi = *VFS_PATH_URL_DELIMITER;
339 return p;
341 *vfs_prefix = '\0';
343 return p;
346 /* --------------------------------------------------------------------------------------------- */
348 const char *
349 vfs_translate_path (const char *path)
351 estr_t state;
353 g_string_set_size (vfs_str_buffer, 0);
354 state = _vfs_translate_path (path, -1, str_cnv_from_term, vfs_str_buffer);
355 return (state != ESTR_FAILURE) ? vfs_str_buffer->str : NULL;
358 /* --------------------------------------------------------------------------------------------- */
360 char *
361 vfs_translate_path_n (const char *path)
363 const char *result;
365 result = vfs_translate_path (path);
366 return g_strdup (result);
369 /* --------------------------------------------------------------------------------------------- */
371 * Get current directory without any OS calls.
373 * @return string contains current path
376 const char *
377 vfs_get_current_dir (void)
379 return current_path->str;
382 /* --------------------------------------------------------------------------------------------- */
384 * Get current directory without any OS calls.
386 * @return newly allocated string contains current path
389 char *
390 vfs_get_current_dir_n (void)
392 return g_strdup (current_path->str);
395 /* --------------------------------------------------------------------------------------------- */
397 * Get raw current directory object without any OS calls.
399 * @return object contain current path
402 const vfs_path_t *
403 vfs_get_raw_current_dir (void)
405 return current_path;
408 /* --------------------------------------------------------------------------------------------- */
410 * Set current directory object.
412 * @param vpath new path
414 void
415 vfs_set_raw_current_dir (const vfs_path_t * vpath)
417 vfs_path_free (current_path);
418 current_path = (vfs_path_t *) vpath;
421 /* --------------------------------------------------------------------------------------------- */
422 /* Return TRUE is the current VFS class is local */
424 gboolean
425 vfs_current_is_local (void)
427 return (current_vfs->flags & VFSF_LOCAL) != 0;
430 /* --------------------------------------------------------------------------------------------- */
431 /* Return flags of the VFS class of the given filename */
433 vfs_class_flags_t
434 vfs_file_class_flags (const vfs_path_t * vpath)
436 const vfs_path_element_t *path_element;
438 path_element = vfs_path_get_by_index (vpath, -1);
439 if (!vfs_path_element_valid (path_element))
440 return VFSF_UNKNOWN;
442 return path_element->class->flags;
445 /* --------------------------------------------------------------------------------------------- */
447 void
448 vfs_init (void)
450 /* create the VFS handle arrays */
451 vfs__classes_list = g_ptr_array_new ();
453 /* create the VFS handle array */
454 vfs_openfiles = g_ptr_array_new ();
456 vfs_str_buffer = g_string_new ("");
460 /* --------------------------------------------------------------------------------------------- */
462 void
463 vfs_setup_work_dir (void)
465 const vfs_path_element_t *path_element;
467 vfs_setup_cwd ();
469 /* FIXME: is we really need for this check? */
471 if (strlen (current_dir) > MC_MAXPATHLEN - 2)
472 vfs_die ("Current dir too long.\n");
475 path_element = vfs_path_get_by_index (current_path, -1);
476 current_vfs = path_element->class;
479 /* --------------------------------------------------------------------------------------------- */
481 void
482 vfs_shut (void)
484 guint i;
486 vfs_gc_done ();
488 vfs_set_raw_current_dir (NULL);
490 for (i = 0; i < vfs__classes_list->len; i++)
492 struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
494 if (vfs->done != NULL)
495 vfs->done (vfs);
498 g_ptr_array_free (vfs_openfiles, TRUE);
499 g_ptr_array_free (vfs__classes_list, TRUE);
500 g_string_free (vfs_str_buffer, TRUE);
501 g_free (mc_readdir_result);
504 /* --------------------------------------------------------------------------------------------- */
506 * These ones grab information from the VFS
507 * and handles them to an upper layer
510 void
511 vfs_fill_names (fill_names_f func)
513 guint i;
515 for (i = 0; i < vfs__classes_list->len; i++)
517 struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
519 if (vfs->fill_names != NULL)
520 vfs->fill_names (vfs, func);
524 /* --------------------------------------------------------------------------------------------- */
525 gboolean
526 vfs_file_is_local (const vfs_path_t * vpath)
528 return (vfs_file_class_flags (vpath) & VFSF_LOCAL) != 0;
531 /* --------------------------------------------------------------------------------------------- */
533 void
534 vfs_print_message (const char *msg, ...)
536 ev_vfs_print_message_t event_data;
537 va_list ap;
539 va_start (ap, msg);
540 event_data.msg = g_strdup_vprintf (msg, ap);
541 va_end (ap);
543 mc_event_raise (MCEVENT_GROUP_CORE, "vfs_print_message", (gpointer) & event_data);
546 /* --------------------------------------------------------------------------------------------- */
548 * If it's local, reread the current directory
549 * from the OS.
552 void
553 vfs_setup_cwd (void)
555 char *current_dir;
556 vfs_path_t *tmp_vpath;
557 const vfs_path_element_t *path_element;
559 if (vfs_get_raw_current_dir () == NULL)
561 current_dir = g_get_current_dir ();
562 vfs_set_raw_current_dir (vfs_path_from_str (current_dir));
563 g_free (current_dir);
565 current_dir = getenv ("PWD");
566 tmp_vpath = vfs_path_from_str (current_dir);
568 if (tmp_vpath != NULL)
570 if (vfs_test_current_dir (tmp_vpath))
571 vfs_set_raw_current_dir (tmp_vpath);
572 else
573 vfs_path_free (tmp_vpath);
577 path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
579 if ((path_element->class->flags & VFSF_LOCAL) != 0)
581 current_dir = g_get_current_dir ();
582 tmp_vpath = vfs_path_from_str (current_dir);
583 g_free (current_dir);
585 if (tmp_vpath != NULL)
587 /* One of directories in the path is not readable */
589 /* Check if it is O.K. to use the current_dir */
590 if (!vfs_test_current_dir (tmp_vpath))
591 vfs_set_raw_current_dir (tmp_vpath);
592 else
593 vfs_path_free (tmp_vpath);
598 /* --------------------------------------------------------------------------------------------- */
600 * Return current directory. If it's local, reread the current directory
601 * from the OS.
604 char *
605 _vfs_get_cwd (void)
607 const vfs_path_t *current_dir_vpath;
609 vfs_setup_cwd ();
610 current_dir_vpath = vfs_get_raw_current_dir ();
611 return g_strdup (vfs_path_as_str (current_dir_vpath));
614 /* --------------------------------------------------------------------------------------------- */
616 * Preallocate space for file in new place for ensure that file
617 * will be fully copied with less fragmentation.
619 * @param dest_vfs_fd mc VFS file handler
620 * @param src_fsize source file size
621 * @param dest_fsize destination file size (if destination exists, otherwise should be 0)
623 * @return 0 if success and non-zero otherwise.
624 * Note: function doesn't touch errno global variable.
628 vfs_preallocate (int dest_vfs_fd, off_t src_fsize, off_t dest_fsize)
630 #ifndef HAVE_POSIX_FALLOCATE
631 (void) dest_vfs_fd;
632 (void) src_fsize;
633 (void) dest_fsize;
634 return 0;
636 #else /* HAVE_POSIX_FALLOCATE */
637 void *dest_fd = NULL;
638 struct vfs_class *dest_class;
640 if (!mc_global.vfs.preallocate_space)
641 return 0;
643 if (src_fsize == 0)
644 return 0;
646 dest_class = vfs_class_find_by_handle (dest_vfs_fd, &dest_fd);
647 if ((dest_class->flags & VFSF_LOCAL) == 0 || dest_fd == NULL)
648 return 0;
650 return posix_fallocate (*(int *) dest_fd, dest_fsize, src_fsize - dest_fsize);
652 #endif /* HAVE_POSIX_FALLOCATE */
655 /* --------------------------------------------------------------------------------------------- */