2 Virtual File System: interface functions
5 The Free Software Foundation, Inc.
8 Slava Zanko <slavazanko@gmail.com>, 2011
10 This file is part of the Midnight Commander.
12 The Midnight Commander is free software: you can redistribute it
13 and/or modify it under the terms of the GNU General Public License as
14 published by the Free Software Foundation, either version 3 of the License,
15 or (at your option) any later version.
17 The Midnight Commander is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program. If not, see <http://www.gnu.org/licenses/>.
28 * \brief Source: Virtual File System: path handlers
37 #include <stdlib.h> /* For atol() */
41 #include <sys/types.h>
43 #include <ctype.h> /* is_digit() */
51 #include "lib/global.h"
53 #include "lib/widget.h" /* message() */
54 #include "lib/strutil.h" /* str_crt_conv_from() */
61 #include "xdirentry.h"
63 extern GString
*vfs_str_buffer
;
64 extern struct vfs_class
*current_vfs
;
66 /*** global variables ****************************************************************************/
68 struct dirent
*mc_readdir_result
= NULL
;
70 /*** file scope macro definitions ****************************************************************/
72 /*** file scope type declarations ****************************************************************/
74 /*** file scope variables ************************************************************************/
76 /*** file scope functions ************************************************************************/
77 /* --------------------------------------------------------------------------------------------- */
80 mc_def_getlocalcopy (const vfs_path_t
* filename_vpath
)
82 vfs_path_t
*tmp_vpath
= NULL
;
83 int fdin
= -1, fdout
= -1;
85 char buffer
[BUF_1K
* 8];
88 fdin
= mc_open (filename_vpath
, O_RDONLY
| O_LINEAR
);
92 fdout
= vfs_mkstemps (&tmp_vpath
, "vfs", vfs_path_get_last_path_str (filename_vpath
));
96 while ((i
= mc_read (fdin
, buffer
, sizeof (buffer
))) > 0)
98 if (write (fdout
, buffer
, i
) != i
)
113 if (mc_stat (filename_vpath
, &mystat
) != -1)
114 mc_chmod (tmp_vpath
, mystat
.st_mode
);
119 vfs_path_free (tmp_vpath
);
127 /* --------------------------------------------------------------------------------------------- */
130 mc_def_ungetlocalcopy (const vfs_path_t
* filename_vpath
,
131 const vfs_path_t
* local_vpath
, gboolean has_changed
)
133 int fdin
= -1, fdout
= -1;
136 local
= vfs_path_get_last_path_str (local_vpath
);
140 char buffer
[BUF_1K
* 8];
143 if (vfs_path_get_last_path_vfs (filename_vpath
)->write
== NULL
)
146 fdin
= open (local
, O_RDONLY
);
149 fdout
= mc_open (filename_vpath
, O_WRONLY
| O_TRUNC
);
152 while ((i
= read (fdin
, buffer
, sizeof (buffer
))) > 0)
153 if (mc_write (fdout
, buffer
, (size_t) i
) != i
)
158 if (close (fdin
) == -1)
164 if (mc_close (fdout
) == -1)
174 message (D_ERROR
, _("Changes to file lost"), "%s", vfs_path_get_last_path_str (filename_vpath
));
183 /* --------------------------------------------------------------------------------------------- */
184 /*** public functions ****************************************************************************/
185 /* --------------------------------------------------------------------------------------------- */
188 mc_open (const vfs_path_t
* vpath
, int flags
, ...)
190 int mode
= 0, result
= -1;
191 const vfs_path_element_t
*path_element
;
196 /* Get the mode flag */
200 va_start (ap
, flags
);
201 mode
= va_arg (ap
, int);
205 path_element
= vfs_path_get_by_index (vpath
, -1);
206 if (vfs_path_element_valid (path_element
) && path_element
->class->open
!= NULL
)
209 /* open must be supported */
210 info
= path_element
->class->open (vpath
, flags
, mode
);
212 errno
= vfs_ferrno (path_element
->class);
214 result
= vfs_new_handle (path_element
->class, info
);
222 /* --------------------------------------------------------------------------------------------- */
226 #define MC_NAMEOP(name, inarg, callarg) \
227 int mc_##name inarg \
230 const vfs_path_element_t *path_element; \
235 path_element = vfs_path_get_by_index (vpath, -1); \
236 if (!vfs_path_element_valid (path_element)) \
241 result = path_element->class->name != NULL ? path_element->class->name callarg : -1; \
243 errno = path_element->class->name != NULL ? vfs_ferrno (path_element->class) : E_NOTSUPP; \
247 MC_NAMEOP (chmod
, (const vfs_path_t
*vpath
, mode_t mode
), (vpath
, mode
))
248 MC_NAMEOP (chown
, (const vfs_path_t
*vpath
, uid_t owner
, gid_t group
), (vpath
, owner
, group
))
249 MC_NAMEOP (utime
, (const vfs_path_t
*vpath
, struct utimbuf
* times
), (vpath
, times
))
250 MC_NAMEOP (readlink
, (const vfs_path_t
*vpath
, char *buf
, size_t bufsiz
), (vpath
, buf
, bufsiz
))
251 MC_NAMEOP (unlink
, (const vfs_path_t
*vpath
), (vpath
))
252 MC_NAMEOP (mkdir
, (const vfs_path_t
*vpath
, mode_t mode
), (vpath
, mode
))
253 MC_NAMEOP (rmdir
, (const vfs_path_t
*vpath
), (vpath
))
254 MC_NAMEOP (mknod
, (const vfs_path_t
*vpath
, mode_t mode
, dev_t dev
), (vpath
, mode
, dev
))
258 /* --------------------------------------------------------------------------------------------- */
261 mc_symlink (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
270 const vfs_path_element_t
*path_element
;
272 path_element
= vfs_path_get_by_index (vpath2
, -1);
273 if (vfs_path_element_valid (path_element
))
276 path_element
->class->symlink
!= NULL
?
277 path_element
->class->symlink (vpath1
, vpath2
) : -1;
281 path_element
->class->symlink
!= NULL
?
282 vfs_ferrno (path_element
->class) : E_NOTSUPP
;
288 /* --------------------------------------------------------------------------------------------- */
292 #define MC_HANDLEOP(name, inarg, callarg) \
293 ssize_t mc_##name inarg \
295 struct vfs_class *vfs; \
299 vfs = vfs_class_find_by_handle (handle); \
302 result = vfs->name != NULL ? vfs->name callarg : -1; \
304 errno = vfs->name != NULL ? vfs_ferrno (vfs) : E_NOTSUPP; \
308 MC_HANDLEOP (read
, (int handle
, void *buffer
, size_t count
), (vfs_class_data_find_by_handle (handle
), buffer
, count
))
309 MC_HANDLEOP (write
, (int handle
, const void *buf
, size_t nbyte
), (vfs_class_data_find_by_handle (handle
), buf
, nbyte
))
311 /* --------------------------------------------------------------------------------------------- */
313 #define MC_RENAMEOP(name) \
314 int mc_##name (const vfs_path_t *vpath1, const vfs_path_t *vpath2) \
317 const vfs_path_element_t *path_element1; \
318 const vfs_path_element_t *path_element2; \
320 if (vpath1 == NULL || vpath2 == NULL) \
323 path_element1 = vfs_path_get_by_index (vpath1, (-1)); \
324 path_element2 = vfs_path_get_by_index (vpath2, (-1)); \
326 if (!vfs_path_element_valid (path_element1) || !vfs_path_element_valid (path_element2) || \
327 path_element1->class != path_element2->class) \
333 result = path_element1->class->name != NULL \
334 ? path_element1->class->name (vpath1, vpath2) \
337 errno = path_element1->class->name != NULL ? vfs_ferrno (path_element1->class) : E_NOTSUPP; \
346 /* --------------------------------------------------------------------------------------------- */
349 mc_ctl (int handle
, int ctlop
, void *arg
)
351 struct vfs_class
*vfs
= vfs_class_find_by_handle (handle
);
356 return vfs
->ctl
? (*vfs
->ctl
) (vfs_class_data_find_by_handle (handle
), ctlop
, arg
) : 0;
359 /* --------------------------------------------------------------------------------------------- */
362 mc_setctl (const vfs_path_t
* vpath
, int ctlop
, void *arg
)
365 const vfs_path_element_t
*path_element
;
368 vfs_die ("You don't want to pass NULL to mc_setctl.");
370 path_element
= vfs_path_get_by_index (vpath
, -1);
371 if (vfs_path_element_valid (path_element
))
373 path_element
->class->setctl
!= NULL
? path_element
->class->setctl (vpath
,
379 /* --------------------------------------------------------------------------------------------- */
382 mc_close (int handle
)
384 struct vfs_class
*vfs
;
387 if (handle
== -1 || !vfs_class_data_find_by_handle (handle
))
390 vfs
= vfs_class_find_by_handle (handle
);
395 return close (handle
);
398 vfs_die ("VFS must support close.\n");
399 result
= (*vfs
->close
) (vfs_class_data_find_by_handle (handle
));
400 vfs_free_handle (handle
);
402 errno
= vfs_ferrno (vfs
);
407 /* --------------------------------------------------------------------------------------------- */
410 mc_opendir (const vfs_path_t
* vpath
)
412 int handle
, *handlep
;
414 vfs_path_element_t
*path_element
;
419 path_element
= (vfs_path_element_t
*) vfs_path_get_by_index (vpath
, -1);
421 if (!vfs_path_element_valid (path_element
))
427 info
= path_element
->class->opendir
? (*path_element
->class->opendir
) (vpath
) : NULL
;
431 errno
= path_element
->class->opendir
? vfs_ferrno (path_element
->class) : E_NOTSUPP
;
435 path_element
->dir
.info
= info
;
438 path_element
->dir
.converter
= (path_element
->encoding
!= NULL
) ?
439 str_crt_conv_from (path_element
->encoding
) : str_cnv_from_term
;
440 if (path_element
->dir
.converter
== INVALID_CONV
)
441 path_element
->dir
.converter
= str_cnv_from_term
;
444 handle
= vfs_new_handle (path_element
->class, vfs_path_element_clone (path_element
));
446 handlep
= g_new (int, 1);
448 return (DIR *) handlep
;
451 /* --------------------------------------------------------------------------------------------- */
454 mc_readdir (DIR * dirp
)
457 struct vfs_class
*vfs
;
458 struct dirent
*entry
= NULL
;
459 vfs_path_element_t
*vfs_path_element
;
461 if (!mc_readdir_result
)
463 /* We can't just allocate struct dirent as (see man dirent.h)
464 * struct dirent has VERY nonnaive semantics of allocating
465 * d_name in it. Moreover, linux's glibc-2.9 allocates dirents _less_,
466 * than 'sizeof (struct dirent)' making full bitwise (sizeof dirent) copy
467 * heap corrupter. So, allocate longliving dirent with at least
468 * (MAXNAMLEN + 1) for d_name in it.
469 * Strictly saying resulting dirent is unusable as we don't adjust internal
470 * structures, holding dirent size. But we don't use it in libc infrastructure.
471 * TODO: to make simpler homemade dirent-alike structure.
473 mc_readdir_result
= (struct dirent
*) g_malloc (sizeof (struct dirent
) + MAXNAMLEN
+ 1);
481 handle
= *(int *) dirp
;
483 vfs
= vfs_class_find_by_handle (handle
);
487 vfs_path_element
= vfs_class_data_find_by_handle (handle
);
490 entry
= (*vfs
->readdir
) (vfs_path_element
->dir
.info
);
494 g_string_set_size (vfs_str_buffer
, 0);
496 str_vfs_convert_from (vfs_path_element
->dir
.converter
, entry
->d_name
, vfs_str_buffer
);
498 g_string_assign (vfs_str_buffer
, entry
->d_name
);
500 mc_readdir_result
->d_ino
= entry
->d_ino
;
501 g_strlcpy (mc_readdir_result
->d_name
, vfs_str_buffer
->str
, MAXNAMLEN
+ 1);
504 errno
= vfs
->readdir
? vfs_ferrno (vfs
) : E_NOTSUPP
;
505 return (entry
!= NULL
) ? mc_readdir_result
: NULL
;
508 /* --------------------------------------------------------------------------------------------- */
511 mc_closedir (DIR * dirp
)
513 int handle
= *(int *) dirp
;
514 struct vfs_class
*vfs
;
517 vfs
= vfs_class_find_by_handle (handle
);
520 vfs_path_element_t
*vfs_path_element
;
521 vfs_path_element
= vfs_class_data_find_by_handle (handle
);
524 if (vfs_path_element
->dir
.converter
!= str_cnv_from_term
)
526 str_close_conv (vfs_path_element
->dir
.converter
);
527 vfs_path_element
->dir
.converter
= INVALID_CONV
;
531 result
= vfs
->closedir
? (*vfs
->closedir
) (vfs_path_element
->dir
.info
) : -1;
532 vfs_free_handle (handle
);
533 vfs_path_element_free (vfs_path_element
);
539 /* --------------------------------------------------------------------------------------------- */
542 mc_stat (const vfs_path_t
* vpath
, struct stat
*buf
)
545 const vfs_path_element_t
*path_element
;
550 path_element
= vfs_path_get_by_index (vpath
, -1);
552 if (vfs_path_element_valid (path_element
))
554 result
= path_element
->class->stat
? (*path_element
->class->stat
) (vpath
, buf
) : -1;
556 errno
= path_element
->class->name
? vfs_ferrno (path_element
->class) : E_NOTSUPP
;
562 /* --------------------------------------------------------------------------------------------- */
565 mc_lstat (const vfs_path_t
* vpath
, struct stat
*buf
)
568 const vfs_path_element_t
*path_element
;
573 path_element
= vfs_path_get_by_index (vpath
, -1);
575 if (vfs_path_element_valid (path_element
))
577 result
= path_element
->class->lstat
? (*path_element
->class->lstat
) (vpath
, buf
) : -1;
579 errno
= path_element
->class->name
? vfs_ferrno (path_element
->class) : E_NOTSUPP
;
585 /* --------------------------------------------------------------------------------------------- */
588 mc_fstat (int handle
, struct stat
*buf
)
590 struct vfs_class
*vfs
;
596 vfs
= vfs_class_find_by_handle (handle
);
600 result
= vfs
->fstat
? (*vfs
->fstat
) (vfs_class_data_find_by_handle (handle
), buf
) : -1;
602 errno
= vfs
->name
? vfs_ferrno (vfs
) : E_NOTSUPP
;
606 /* --------------------------------------------------------------------------------------------- */
609 mc_getlocalcopy (const vfs_path_t
* pathname_vpath
)
611 vfs_path_t
*result
= NULL
;
612 const vfs_path_element_t
*path_element
;
614 if (pathname_vpath
== NULL
)
617 path_element
= vfs_path_get_by_index (pathname_vpath
, -1);
619 if (vfs_path_element_valid (path_element
))
621 result
= path_element
->class->getlocalcopy
!= NULL
?
622 path_element
->class->getlocalcopy (pathname_vpath
) :
623 mc_def_getlocalcopy (pathname_vpath
);
625 errno
= vfs_ferrno (path_element
->class);
630 /* --------------------------------------------------------------------------------------------- */
633 mc_ungetlocalcopy (const vfs_path_t
* pathname_vpath
, const vfs_path_t
* local_vpath
,
634 gboolean has_changed
)
636 int return_value
= -1;
637 const vfs_path_element_t
*path_element
;
639 if (pathname_vpath
== NULL
)
642 path_element
= vfs_path_get_by_index (pathname_vpath
, -1);
644 if (vfs_path_element_valid (path_element
))
645 return_value
= path_element
->class->ungetlocalcopy
!= NULL
?
646 path_element
->class->ungetlocalcopy (pathname_vpath
, local_vpath
, has_changed
) :
647 mc_def_ungetlocalcopy (pathname_vpath
, local_vpath
, has_changed
);
652 /* --------------------------------------------------------------------------------------------- */
656 * @param vpath VFS-path
658 * @return 0 on success, -1 on failure.
662 mc_chdir (const vfs_path_t
* vpath
)
664 struct vfs_class
*old_vfs
;
667 const vfs_path_element_t
*path_element
;
668 vfs_path_t
*cd_vpath
;
674 cd_vpath
= vfs_path_to_absolute (vpath
);
676 cd_vpath
= vfs_path_clone (vpath
);
678 path_element
= vfs_path_get_by_index (cd_vpath
, -1);
680 if (!vfs_path_element_valid (path_element
) || path_element
->class->chdir
== NULL
)
685 result
= (*path_element
->class->chdir
) (cd_vpath
);
689 errno
= vfs_ferrno (path_element
->class);
693 old_vfsid
= vfs_getid (vfs_get_raw_current_dir ());
694 old_vfs
= current_vfs
;
696 /* Actually change directory */
697 vfs_set_raw_current_dir (cd_vpath
);
699 current_vfs
= path_element
->class;
701 /* This function uses the new current_dir implicitly */
702 vfs_stamp_create (old_vfs
, old_vfsid
);
704 /* Sometimes we assume no trailing slash on cwd */
705 path_element
= vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
706 if (vfs_path_element_valid (path_element
))
708 if (*path_element
->path
!= '\0')
712 p
= strchr (path_element
->path
, 0) - 1;
713 if (*p
== PATH_SEP
&& p
> path_element
->path
)
717 #ifdef ENABLE_VFS_NET
719 struct vfs_s_super
*super
;
721 super
= vfs_get_super_by_vpath (vpath
);
722 if (super
!= NULL
&& super
->path_element
!= NULL
)
724 g_free (super
->path_element
->path
);
725 super
->path_element
->path
= g_strdup (path_element
->path
);
728 #endif /* ENABLE_VFS_NET */
734 vfs_path_free (cd_vpath
);
738 /* --------------------------------------------------------------------------------------------- */
741 mc_lseek (int fd
, off_t offset
, int whence
)
743 struct vfs_class
*vfs
;
749 vfs
= vfs_class_find_by_handle (fd
);
753 result
= vfs
->lseek
? (*vfs
->lseek
) (vfs_class_data_find_by_handle (fd
), offset
, whence
) : -1;
755 errno
= vfs
->lseek
? vfs_ferrno (vfs
) : E_NOTSUPP
;
759 /* --------------------------------------------------------------------------------------------- */
760 /* Following code heavily borrows from libiberty, mkstemps.c */
763 * pname (output) - pointer to the name of the temp file (needs g_free).
764 * NULL if the function fails.
765 * prefix - part of the filename before the random part.
766 * Prepend $TMPDIR or /tmp if there are no path separators.
767 * suffix - if not NULL, part of the filename after the random part.
770 * handle of the open file or -1 if couldn't open any.
774 mc_mkstemps (vfs_path_t
** pname_vpath
, const char *prefix
, const char *suffix
)
779 if (strchr (prefix
, PATH_SEP
) != NULL
)
780 p1
= g_strdup (prefix
);
783 /* Add prefix first to find the position of XXXXXX */
784 p1
= g_build_filename (mc_tmpdir (), prefix
, (char *) NULL
);
787 p2
= g_strconcat (p1
, "XXXXXX", suffix
, (char *) NULL
);
792 *pname_vpath
= vfs_path_from_str (p2
);
804 /* --------------------------------------------------------------------------------------------- */
806 * Return the directory where mc should keep its temporary files.
807 * This directory is (in Bourne shell terms) "${TMPDIR=/tmp}/mc-$USER"
808 * When called the first time, the directory is created if needed.
809 * The first call should be done early, since we are using fprintf()
810 * and not message() to report possible problems.
816 static char buffer
[64];
817 static const char *tmpdir
= NULL
;
821 const char *error
= NULL
;
823 /* Check if already correctly initialized */
824 if (tmpdir
&& lstat (tmpdir
, &st
) == 0 && S_ISDIR (st
.st_mode
) &&
825 st
.st_uid
== getuid () && (st
.st_mode
& 0777) == 0700)
828 sys_tmp
= getenv ("TMPDIR");
829 if (!sys_tmp
|| sys_tmp
[0] != '/')
831 sys_tmp
= TMPDIR_DEFAULT
;
834 pwd
= getpwuid (getuid ());
837 g_snprintf (buffer
, sizeof (buffer
), "%s/mc-%s", sys_tmp
, pwd
->pw_name
);
839 g_snprintf (buffer
, sizeof (buffer
), "%s/mc-%lu", sys_tmp
, (unsigned long) getuid ());
841 canonicalize_pathname (buffer
);
843 if (lstat (buffer
, &st
) == 0)
845 /* Sanity check for existing directory */
846 if (!S_ISDIR (st
.st_mode
))
847 error
= _("%s is not a directory\n");
848 else if (st
.st_uid
!= getuid ())
849 error
= _("Directory %s is not owned by you\n");
850 else if (((st
.st_mode
& 0777) != 0700) && (chmod (buffer
, 0700) != 0))
851 error
= _("Cannot set correct permissions for directory %s\n");
855 /* Need to create directory */
856 if (mkdir (buffer
, S_IRWXU
) != 0)
859 _("Cannot create temporary directory %s: %s\n"),
860 buffer
, unix_error_string (errno
));
868 char *fallback_prefix
;
869 gboolean fallback_ok
= FALSE
;
870 vfs_path_t
*test_vpath
;
873 fprintf (stderr
, error
, buffer
);
875 /* Test if sys_tmp is suitable for temporary files */
876 fallback_prefix
= g_strdup_printf ("%s/mctest", sys_tmp
);
877 test_fd
= mc_mkstemps (&test_vpath
, fallback_prefix
, NULL
);
878 g_free (fallback_prefix
);
883 test_fn
= vfs_path_to_str (test_vpath
);
885 test_fd
= open (test_fn
, O_RDONLY
);
897 fprintf (stderr
, _("Temporary files will be created in %s\n"), sys_tmp
);
898 g_snprintf (buffer
, sizeof (buffer
), "%s", sys_tmp
);
903 fprintf (stderr
, _("Temporary files will not be created\n"));
904 g_snprintf (buffer
, sizeof (buffer
), "%s", "/dev/null/");
907 vfs_path_free (test_vpath
);
908 fprintf (stderr
, "%s\n", _("Press any key to continue..."));
915 g_setenv ("MC_TMPDIR", tmpdir
, TRUE
);
920 /* --------------------------------------------------------------------------------------------- */