/* *INDENT-OFF* */
END_PARAMETRIZED_TEST
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
/* @Test */
/* *INDENT-OFF* */
START_TEST (the_file_is_remote_but_empty)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *filename_vpath;
filename_vpath = NULL;
vfs_file_is_local__return_value = FALSE;
/* when */
execute_with_vfs_arg ("cmd_for_remote_file", filename_vpath);
/* then */
mctest_assert_str_eq (do_execute__lc_shell__captured, NULL);
mctest_assert_str_eq (do_execute__command__captured, NULL);
mctest_assert_int_eq (vfs_file_is_local__vpath__captured->len, 2);
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (vfs_file_is_local__vpath__captured, 0),
vfs_get_raw_current_dir ()), TRUE);
fail_unless (g_ptr_array_index (vfs_file_is_local__vpath__captured, 1) == NULL,
"\nParameter for second call to vfs_file_is_local() should be NULL!");
fail_unless (mc_getlocalcopy__pathname_vpath__captured == NULL,
"\nFunction mc_getlocalcopy() shouldn't be called!");
vfs_path_free (filename_vpath);
}
/* *INDENT-OFF* */
START_PARAMETRIZED_TEST (the_file_is_local, the_file_is_local_ds)
/* *INDENT-ON* */
{
/* given */
vfs_path_t *filename_vpath;
filename_vpath = vfs_path_from_str (data->input_path);
vfs_file_is_local__return_value = TRUE;
/* when */
execute_with_vfs_arg ("cmd_for_local_file", filename_vpath);
/* then */
mctest_assert_str_eq (do_execute__lc_shell__captured, "cmd_for_local_file");
mctest_assert_str_eq (do_execute__command__captured, data->input_path);
mctest_assert_int_eq (vfs_file_is_local__vpath__captured->len, 1);
{
const vfs_path_t *tmp_vpath;
tmp_vpath = (data->input_path == NULL) ? vfs_get_raw_current_dir () : filename_vpath;
mctest_assert_int_eq (vfs_path_equal
(g_ptr_array_index (vfs_file_is_local__vpath__captured, 0),
tmp_vpath), TRUE);
}
mctest_assert_int_eq (do_execute__flags__captured, EXECUTE_INTERNAL);
fail_unless (mc_getlocalcopy__pathname_vpath__captured == NULL,
"\nFunction mc_getlocalcopy() shouldn't be called!");
vfs_path_free (filename_vpath);
}
static gboolean
execute_prepare_with_vfs_arg (const vfs_path_t * filename_vpath, vfs_path_t ** localcopy_vpath,
time_t * mtime)
{
struct stat st;
/* Simplest case, this file is local */
if ((filename_vpath == NULL && vfs_file_is_local (vfs_get_raw_current_dir ()))
|| vfs_file_is_local (filename_vpath))
return TRUE;
/* FIXME: Creation of new files on VFS is not supported */
if (filename_vpath == NULL)
return FALSE;
*localcopy_vpath = mc_getlocalcopy (filename_vpath);
if (*localcopy_vpath == NULL)
{
message (D_ERROR, MSG_ERROR, _("Cannot fetch a local copy of %s"),
vfs_path_as_str (filename_vpath));
return FALSE;
}
mc_stat (*localcopy_vpath, &st);
*mtime = st.st_mtime;
return TRUE;
}
static vfs_path_t *
get_absolute_name (const vfs_path_t * vpath)
{
if (vpath == NULL)
return NULL;
if (IS_PATH_SEP (*vfs_path_get_by_index (vpath, 0)->path))
return vfs_path_clone (vpath);
return vfs_path_append_vpath_new (vfs_get_raw_current_dir (), vpath, NULL);
}
static void
tree_rescan (void *data)
{
WTree *tree = data;
int ret;
vfs_path_t *old_vpath;
old_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
if (old_vpath == NULL)
return;
if (tree->selected_ptr != NULL && mc_chdir (tree->selected_ptr->name) == 0)
{
tree_store_rescan (tree->selected_ptr->name);
ret = mc_chdir (old_vpath);
}
vfs_path_free (old_vpath);
}
gboolean
mcview_load (mcview_t * view, const char *command, const char *file, int start_line)
{
gboolean retval = FALSE;
vfs_path_t *vpath = NULL;
#ifdef HAVE_ASSERT_H
assert (view->bytes_per_line != 0);
#endif
view->filename_vpath = vfs_path_from_str (file);
/* get working dir */
if (file != NULL && file[0] != '\0')
{
vfs_path_free (view->workdir_vpath);
if (!g_path_is_absolute (file))
{
vfs_path_t *p;
p = vfs_path_clone (vfs_get_raw_current_dir ());
view->workdir_vpath = vfs_path_append_new (p, file, (char *) NULL);
vfs_path_free (p);
}
else
{
/* try extract path form filename */
const char *fname;
char *dir;
fname = x_basename (file);
dir = g_strndup (file, (size_t) (fname - file));
view->workdir_vpath = vfs_path_from_str (dir);
g_free (dir);
}
}
if (!mcview_is_in_panel (view))
view->dpy_text_column = 0;
mcview_set_codeset (view);
if (command != NULL && (view->magic_mode || file == NULL || file[0] == '\0'))
retval = mcview_load_command_output (view, command);
else if (file != NULL && file[0] != '\0')
{
int fd;
char tmp[BUF_MEDIUM];
struct stat st;
/* Open the file */
vpath = vfs_path_from_str (file);
fd = mc_open (vpath, O_RDONLY | O_NONBLOCK);
if (fd == -1)
{
g_snprintf (tmp, sizeof (tmp), _("Cannot open \"%s\"\n%s"),
file, unix_error_string (errno));
mcview_show_error (view, tmp);
vfs_path_free (view->filename_vpath);
view->filename_vpath = NULL;
vfs_path_free (view->workdir_vpath);
view->workdir_vpath = NULL;
goto finish;
}
/* Make sure we are working with a regular file */
if (mc_fstat (fd, &st) == -1)
{
mc_close (fd);
g_snprintf (tmp, sizeof (tmp), _("Cannot stat \"%s\"\n%s"),
file, unix_error_string (errno));
mcview_show_error (view, tmp);
vfs_path_free (view->filename_vpath);
view->filename_vpath = NULL;
vfs_path_free (view->workdir_vpath);
view->workdir_vpath = NULL;
goto finish;
}
if (!S_ISREG (st.st_mode))
{
mc_close (fd);
mcview_show_error (view, _("Cannot view: not a regular file"));
vfs_path_free (view->filename_vpath);
view->filename_vpath = NULL;
vfs_path_free (view->workdir_vpath);
view->workdir_vpath = NULL;
goto finish;
}
if (st.st_size == 0 || mc_lseek (fd, 0, SEEK_SET) == -1)
{
/* Must be one of those nice files that grow (/proc) */
mcview_set_datasource_vfs_pipe (view, fd);
}
else
{
int type;
type = get_compression_type (fd, file);
if (view->magic_mode && (type != COMPRESSION_NONE))
{
char *tmp_filename;
vfs_path_t *vpath1;
int fd1;
tmp_filename = g_strconcat (file, decompress_extension (type), (char *) NULL);
vpath1 = vfs_path_from_str (tmp_filename);
fd1 = mc_open (vpath1, O_RDONLY | O_NONBLOCK);
if (fd1 == -1)
{
g_snprintf (tmp, sizeof (tmp), _("Cannot open \"%s\" in parse mode\n%s"),
file, unix_error_string (errno));
mcview_show_error (view, tmp);
}
else
{
mc_close (fd);
fd = fd1;
mc_fstat (fd, &st);
}
vfs_path_free (vpath1);
g_free (tmp_filename);
}
mcview_set_datasource_file (view, fd, &st);
}
retval = TRUE;
}
finish:
view->command = g_strdup (command);
view->dpy_start = 0;
view->search_start = 0;
view->search_end = 0;
view->dpy_text_column = 0;
mcview_compute_areas (view);
mcview_update_bytes_per_line (view);
if (mcview_remember_file_position && view->filename_vpath != NULL && start_line == 0)
{
long line, col;
off_t new_offset, max_offset;
load_file_position (view->filename_vpath, &line, &col, &new_offset, &view->saved_bookmarks);
max_offset = mcview_get_filesize (view) - 1;
if (max_offset < 0)
new_offset = 0;
else
new_offset = min (new_offset, max_offset);
if (!view->hex_mode)
view->dpy_start = mcview_bol (view, new_offset, 0);
else
{
view->dpy_start = new_offset - new_offset % view->bytes_per_line;
view->hex_cursor = new_offset;
}
}
else if (start_line > 0)
mcview_moveto (view, start_line - 1, 0);
view->hexedit_lownibble = FALSE;
view->hexview_in_text = FALSE;
view->change_list = NULL;
vfs_path_free (vpath);
return retval;
}
void
do_executev (const char *shell, int flags, char *const argv[])
{
#ifdef ENABLE_SUBSHELL
vfs_path_t *new_dir_vpath = NULL;
#endif /* ENABLE_SUBSHELL */
vfs_path_t *old_vfs_dir_vpath = NULL;
if (!vfs_current_is_local ())
old_vfs_dir_vpath = vfs_path_clone (vfs_get_raw_current_dir ());
if (mc_global.mc_run_mode == MC_RUN_FULL)
save_cwds_stat ();
pre_exec ();
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_RESTORE);
if (!mc_global.tty.use_subshell && *argv != NULL && (flags & EXECUTE_INTERNAL) == 0)
{
printf ("%s%s\n", mc_prompt, *argv);
fflush (stdout);
}
#ifdef ENABLE_SUBSHELL
if (mc_global.tty.use_subshell && (flags & EXECUTE_INTERNAL) == 0)
{
do_update_prompt ();
/* We don't care if it died, higher level takes care of this */
invoke_subshell (*argv, VISIBLY, old_vfs_dir_vpath != NULL ? NULL : &new_dir_vpath);
}
else
#endif /* ENABLE_SUBSHELL */
my_systemv_flags (flags, shell, argv);
if ((flags & EXECUTE_INTERNAL) == 0)
{
if ((pause_after_run == pause_always
|| (pause_after_run == pause_on_dumb_terminals && !mc_global.tty.xterm_flag
&& mc_global.tty.console_flag == '\0')) && quit == 0
#ifdef ENABLE_SUBSHELL
&& subshell_state != RUNNING_COMMAND
#endif /* ENABLE_SUBSHELL */
)
{
printf (_("Press any key to continue..."));
fflush (stdout);
tty_raw_mode ();
get_key_code (0);
printf ("\r\n");
fflush (stdout);
}
if (mc_global.tty.console_flag != '\0' && output_lines != 0 && mc_global.keybar_visible)
{
putchar ('\n');
fflush (stdout);
}
}
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_SAVE);
edition_post_exec ();
#ifdef ENABLE_SUBSHELL
if (new_dir_vpath != NULL)
{
do_possible_cd (new_dir_vpath);
vfs_path_free (new_dir_vpath);
}
#endif /* ENABLE_SUBSHELL */
if (old_vfs_dir_vpath != NULL)
{
mc_chdir (old_vfs_dir_vpath);
vfs_path_free (old_vfs_dir_vpath);
}
if (mc_global.mc_run_mode == MC_RUN_FULL)
{
update_panels (UP_OPTIMIZE, UP_KEEPSEL);
update_xterm_title_path ();
}
do_refresh ();
use_dash (TRUE);
}