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 int
my_mkdir_rec (char *s, mode_t mode)
{
char *p, *q;
int result;
if (!mc_mkdir (s, mode))
return 0;
else if (errno != ENOENT)
return -1;
/* FIXME: should check instead if s is at the root of that filesystem */
if (!vfs_file_is_local (s))
return -1;
if (!strcmp (s, PATH_SEP_STR)) {
errno = ENOTDIR;
return -1;
}
p = concat_dir_and_file (s, "..");
q = vfs_canon (p);
g_free (p);
if (!(result = my_mkdir_rec (q, mode)))
result = mc_mkdir (s, mode);
g_free (q);
return result;
}
static int
my_mkdir_rec (const vfs_path_t * s_vpath, mode_t mode)
{
vfs_path_t *q;
int result;
if (mc_mkdir (s_vpath, mode) == 0)
return 0;
if (errno != ENOENT)
return (-1);
/* FIXME: should check instead if s_vpath is at the root of that filesystem */
if (!vfs_file_is_local (s_vpath))
return (-1);
if (strcmp (vfs_path_as_str (s_vpath), PATH_SEP_STR) == 0)
{
errno = ENOTDIR;
return (-1);
}
q = vfs_path_append_new (s_vpath, "..", NULL);
result = my_mkdir_rec (q, mode);
vfs_path_free (q);
if (result == 0)
result = mc_mkdir (s_vpath, mode);
return result;
}
FBUF *
f_open (const char *filename, int flags)
{
int fd;
FBUF *fs;
fs = f_dopen(0);
if (fs == NULL) {
return NULL;
}
fs->name = g_strdup(filename);
if (!fs->name) {
f_free(fs);
return NULL;
}
if (vfs_file_is_local(filename)) {
fd = open(filename, flags);
} else {
fd = -1;
fs->data = mc_getlocalcopy(filename);
if (fs->data) {
fs->flags = FILE_FLAG_COPY;
fd = open(fs->data, flags);
}
}
if (fd < 0) {
f_free(fs);
return NULL;
}
fs->fd = fd;
return fs;
}
/*
* Execute command on a filename that can be on VFS.
* Errors are reported to the user.
*/
void
execute_with_vfs_arg (const char *command, const char *filename)
{
char *localcopy;
char *fn;
struct stat st;
time_t mtime;
/* Simplest case, this file is local */
if (!filename || vfs_file_is_local (filename)) {
do_execute (command, filename, EXECUTE_INTERNAL);
return;
}
/* FIXME: Creation of new files on VFS is not supported */
if (!*filename)
return;
localcopy = mc_getlocalcopy (filename);
if (localcopy == NULL) {
message (1, MSG_ERROR, _(" Cannot fetch a local copy of %s "),
filename);
return;
}
/*
* filename can be an entry on panel, it can be changed by executing
* the command, so make a copy. Smarter VFS code would make the code
* below unnecessary.
*/
fn = g_strdup (filename);
mc_stat (localcopy, &st);
mtime = st.st_mtime;
do_execute (command, localcopy, EXECUTE_INTERNAL);
mc_stat (localcopy, &st);
mc_ungetlocalcopy (fn, localcopy, mtime != st.st_mtime);
g_free (localcopy);
g_free (fn);
}
static void
exec_extension (const char *filename, const char *data, int *move_dir,
int start_line)
{
char *file_name;
int cmd_file_fd;
FILE *cmd_file;
char *cmd = NULL;
int expand_prefix_found = 0;
int parameter_found = 0;
char prompt[80];
int run_view = 0;
int def_hex_mode = default_hex_mode, changed_hex_mode = 0;
int def_nroff_flag = default_nroff_flag, changed_nroff_flag = 0;
int written_nonspace = 0;
int is_cd = 0;
char buffer[1024];
char *p = 0;
char *localcopy = NULL;
int do_local_copy;
time_t localmtime = 0;
struct stat mystat;
quote_func_t quote_func = name_quote;
g_return_if_fail (filename != NULL);
g_return_if_fail (data != NULL);
/* Avoid making a local copy if we are doing a cd */
if (!vfs_file_is_local (filename))
do_local_copy = 1;
else
do_local_copy = 0;
/*
* All commands should be run in /bin/sh regardless of user shell.
* To do that, create temporary shell script and run it.
* Sometimes it's not needed (e.g. for %cd and %view commands),
* but it's easier to create it anyway.
*/
cmd_file_fd = mc_mkstemps (&file_name, "mcext", SCRIPT_SUFFIX);
if (cmd_file_fd == -1) {
message (1, MSG_ERROR,
_(" Cannot create temporary command file \n %s "),
unix_error_string (errno));
return;
}
cmd_file = fdopen (cmd_file_fd, "w");
fputs ("#! /bin/sh\n", cmd_file);
prompt[0] = 0;
for (; *data && *data != '\n'; data++) {
if (parameter_found) {
if (*data == '}') {
char *parameter;
parameter_found = 0;
parameter = input_dialog (_(" Parameter "), prompt, "");
if (!parameter) {
/* User canceled */
fclose (cmd_file);
unlink (file_name);
if (localcopy) {
mc_ungetlocalcopy (filename, localcopy, 0);
g_free (localcopy);
}
g_free (file_name);
return;
}
fputs (parameter, cmd_file);
written_nonspace = 1;
g_free (parameter);
} else {
size_t len = strlen (prompt);
if (len < sizeof (prompt) - 1) {
prompt[len] = *data;
prompt[len + 1] = 0;
}
}
} else if (expand_prefix_found) {
expand_prefix_found = 0;
if (*data == '{')
parameter_found = 1;
else {
int i = check_format_view (data);
char *v;
if (i) {
data += i - 1;
run_view = 1;
} else if ((i = check_format_cd (data)) > 0) {
is_cd = 1;
quote_func = fake_name_quote;
do_local_copy = 0;
p = buffer;
data += i - 1;
} else if ((i = check_format_var (data, &v)) > 0 && v) {
fputs (v, cmd_file);
g_free (v);
data += i;
} else {
char *text;
if (*data == 'f') {
if (do_local_copy) {
localcopy = mc_getlocalcopy (filename);
if (localcopy == NULL) {
fclose (cmd_file);
unlink (file_name);
g_free (file_name);
return;
}
mc_stat (localcopy, &mystat);
localmtime = mystat.st_mtime;
text = (*quote_func) (localcopy, 0);
} else {
text = (*quote_func) (filename, 0);
}
} else
text = expand_format (NULL, *data, !is_cd);
if (!is_cd)
fputs (text, cmd_file);
else {
strcpy (p, text);
p = strchr (p, 0);
}
g_free (text);
written_nonspace = 1;
}
}
} else {
if (*data == '%')
expand_prefix_found = 1;
else {
if (*data != ' ' && *data != '\t')
written_nonspace = 1;
if (is_cd)
*(p++) = *data;
else
fputc (*data, cmd_file);
}
}
} /* for */
/*
* Make the script remove itself when it finishes.
* Don't do it for the viewer - it may need to rerun the script,
* so we clean up after calling view().
*/
if (!run_view) {
fprintf (cmd_file, "\n/bin/rm -f %s\n", file_name);
}
fclose (cmd_file);
if ((run_view && !written_nonspace) || is_cd) {
unlink (file_name);
g_free (file_name);
file_name = NULL;
} else {
/* Set executable flag on the command file ... */
chmod (file_name, S_IRWXU);
/* ... but don't rely on it - run /bin/sh explicitly */
cmd = g_strconcat ("/bin/sh ", file_name, (char *) NULL);
}
if (run_view) {
altered_hex_mode = 0;
altered_nroff_flag = 0;
if (def_hex_mode != default_hex_mode)
changed_hex_mode = 1;
if (def_nroff_flag != default_nroff_flag)
changed_nroff_flag = 1;
/* If we've written whitespace only, then just load filename
* into view
*/
if (written_nonspace) {
view (cmd, filename, move_dir, start_line);
unlink (file_name);
} else {
view (0, filename, move_dir, start_line);
}
if (changed_hex_mode && !altered_hex_mode)
default_hex_mode = def_hex_mode;
if (changed_nroff_flag && !altered_nroff_flag)
default_nroff_flag = def_nroff_flag;
repaint_screen ();
} else if (is_cd) {
char *q;
*p = 0;
p = buffer;
/* while (*p == ' ' && *p == '\t')
* p++;
*/
/* Search last non-space character. Start search at the end in order
not to short filenames containing spaces. */
q = p + strlen (p) - 1;
while (q >= p && (*q == ' ' || *q == '\t'))
q--;
q[1] = 0;
do_cd (p, cd_parse_command);
} else {
shell_execute (cmd, EXECUTE_INTERNAL);
if (console_flag) {
handle_console (CONSOLE_SAVE);
if (output_lines && keybar_visible) {
show_console_contents (output_start_y,
LINES - keybar_visible -
output_lines - 1,
LINES - keybar_visible - 1);
}
}
}
g_free (file_name);
g_free (cmd);
if (localcopy) {
mc_stat (localcopy, &mystat);
mc_ungetlocalcopy (filename, localcopy,
localmtime != mystat.st_mtime);
g_free (localcopy);
}
}
static FILE *
extfs_open_archive (int fstype, const char *name, struct archive **pparc)
{
static dev_t archive_counter = 0;
FILE *result;
mode_t mode;
char *cmd;
char *mc_extfsdir;
struct stat mystat;
struct archive *current_archive;
struct entry *root_entry;
char *local_name = NULL, *tmp = 0;
int uses_archive = extfs_need_archive[fstype];
if (uses_archive) {
if (mc_stat (name, &mystat) == -1)
return NULL;
if (!vfs_file_is_local (name)) {
local_name = mc_getlocalcopy (name);
if (local_name == NULL)
return NULL;
}
tmp = name_quote (name, 0);
}
mc_extfsdir = concat_dir_and_file (mc_home, "extfs" PATH_SEP_STR);
cmd =
g_strconcat (mc_extfsdir, extfs_prefixes[fstype], " list ",
local_name ? local_name : tmp, (char *) NULL);
g_free (tmp);
g_free (mc_extfsdir);
open_error_pipe ();
result = popen (cmd, "r");
g_free (cmd);
if (result == NULL) {
close_error_pipe (1, NULL);
if (local_name) {
mc_ungetlocalcopy (name, local_name, 0);
g_free(local_name);
}
return NULL;
}
#ifdef ___QNXNTO__
setvbuf (result, NULL, _IONBF, 0);
#endif
current_archive = g_new (struct archive, 1);
current_archive->fstype = fstype;
current_archive->name = name ? g_strdup (name) : NULL;
current_archive->local_name = local_name;
if (local_name != NULL)
mc_stat (local_name, ¤t_archive->local_stat);
current_archive->inode_counter = 0;
current_archive->fd_usage = 0;
current_archive->rdev = archive_counter++;
current_archive->next = first_archive;
first_archive = current_archive;
mode = mystat.st_mode & 07777;
if (mode & 0400)
mode |= 0100;
if (mode & 0040)
mode |= 0010;
if (mode & 0004)
mode |= 0001;
mode |= S_IFDIR;
root_entry = extfs_generate_entry (current_archive, "/", NULL, mode);
root_entry->inode->uid = mystat.st_uid;
root_entry->inode->gid = mystat.st_gid;
root_entry->inode->atime = mystat.st_atime;
root_entry->inode->ctime = mystat.st_ctime;
root_entry->inode->mtime = mystat.st_mtime;
current_archive->root_entry = root_entry;
*pparc = current_archive;
return result;
}
static vfs_path_t *
exec_extension (void *target, const vfs_path_t * filename_vpath, const char *lc_data,
int start_line)
{
char *shell_string, *export_variables;
vfs_path_t *script_vpath = NULL;
int cmd_file_fd;
FILE *cmd_file;
char *cmd = NULL;
g_return_val_if_fail (lc_data != NULL, NULL);
pbuffer = NULL;
localmtime = 0;
quote_func = name_quote;
run_view = FALSE;
is_cd = FALSE;
written_nonspace = FALSE;
/* Avoid making a local copy if we are doing a cd */
do_local_copy = !vfs_file_is_local (filename_vpath);
shell_string = exec_make_shell_string (lc_data, filename_vpath);
if (shell_string == NULL)
goto ret;
if (is_cd)
{
exec_extension_cd ();
g_free (shell_string);
goto ret;
}
/*
* All commands should be run in /bin/sh regardless of user shell.
* To do that, create temporary shell script and run it.
* Sometimes it's not needed (e.g. for %cd and %view commands),
* but it's easier to create it anyway.
*/
cmd_file_fd = mc_mkstemps (&script_vpath, "mcext", SCRIPT_SUFFIX);
if (cmd_file_fd == -1)
{
message (D_ERROR, MSG_ERROR,
_("Cannot create temporary command file\n%s"), unix_error_string (errno));
goto ret;
}
cmd_file = fdopen (cmd_file_fd, "w");
fputs ("#! /bin/sh\n\n", cmd_file);
export_variables = exec_get_export_variables (filename_vpath);
if (export_variables != NULL)
{
fprintf (cmd_file, "%s\n", export_variables);
g_free (export_variables);
}
fputs (shell_string, cmd_file);
g_free (shell_string);
/*
* Make the script remove itself when it finishes.
* Don't do it for the viewer - it may need to rerun the script,
* so we clean up after calling view().
*/
if (!run_view)
fprintf (cmd_file, "\n/bin/rm -f %s\n", vfs_path_as_str (script_vpath));
fclose (cmd_file);
if ((run_view && !written_nonspace) || is_cd)
{
exec_cleanup_script (script_vpath);
script_vpath = NULL;
}
else
{
/* Set executable flag on the command file ... */
mc_chmod (script_vpath, S_IRWXU);
/* ... but don't rely on it - run /bin/sh explicitly */
cmd = g_strconcat ("/bin/sh ", vfs_path_as_str (script_vpath), (char *) NULL);
}
if (run_view)
{
/* If we've written whitespace only, then just load filename into view */
if (!written_nonspace)
exec_extension_view (target, NULL, filename_vpath, start_line);
else
exec_extension_view (target, cmd, filename_vpath, start_line);
}
else
{
shell_execute (cmd, EXECUTE_INTERNAL);
if (mc_global.tty.console_flag != '\0')
{
handle_console (CONSOLE_SAVE);
if (output_lines && mc_global.keybar_visible)
show_console_contents (output_start_y,
LINES - mc_global.keybar_visible -
output_lines - 1, LINES - mc_global.keybar_visible - 1);
}
}
g_free (cmd);
exec_cleanup_file_name (filename_vpath, TRUE);
ret:
return script_vpath;
}
int
main (int argc, char *argv[])
{
GError *mcerror = NULL;
gboolean config_migrated = FALSE;
char *config_migrate_msg;
int exit_code = EXIT_FAILURE;
mc_global.timer = mc_timer_new ();
/* We had LC_CTYPE before, LC_ALL includs LC_TYPE as well */
#ifdef HAVE_SETLOCALE
(void) setlocale (LC_ALL, "");
#endif
(void) bindtextdomain (PACKAGE, LOCALEDIR);
(void) textdomain (PACKAGE);
/* do this before args parsing */
str_init_strings (NULL);
if (!mc_args_parse (&argc, &argv, "mc", &mcerror))
{
startup_exit_falure:
fprintf (stderr, _("Failed to run:\n%s\n"), mcerror->message);
g_error_free (mcerror);
g_free (mc_global.tty.shell);
startup_exit_ok:
str_uninit_strings ();
mc_timer_destroy (mc_global.timer);
return exit_code;
}
/* do this before mc_args_show_info () to view paths in the --datadir-info output */
OS_Setup ();
if (!g_path_is_absolute (mc_config_get_home_dir ()))
{
mc_propagate_error (&mcerror, 0, "%s: %s", _("Home directory path is not absolute"),
mc_config_get_home_dir ());
mc_event_deinit (NULL);
goto startup_exit_falure;
}
if (!mc_args_show_info ())
{
exit_code = EXIT_SUCCESS;
goto startup_exit_ok;
}
if (!events_init (&mcerror))
goto startup_exit_falure;
mc_config_init_config_paths (&mcerror);
config_migrated = mc_config_migrate_from_old_place (&mcerror, &config_migrate_msg);
if (mcerror != NULL)
{
mc_event_deinit (NULL);
goto startup_exit_falure;
}
vfs_init ();
vfs_plugins_init ();
load_setup ();
/* Must be done after load_setup because depends on mc_global.vfs.cd_symlinks */
vfs_setup_work_dir ();
/* Resolve the other_dir panel option. Must be done after vfs_setup_work_dir */
{
char *buffer;
vfs_path_t *vpath;
buffer = mc_config_get_string (mc_panels_config, "Dirs", "other_dir", ".");
vpath = vfs_path_from_str (buffer);
if (vfs_file_is_local (vpath))
saved_other_dir = buffer;
else
g_free (buffer);
vfs_path_free (vpath);
}
/* Set up temporary directory after VFS initialization */
mc_tmpdir ();
/* do this after vfs initialization and vfs working directory setup
due to mc_setctl() and mcedit_arg_vpath_new() calls in mc_setup_by_args() */
if (!mc_setup_by_args (argc, argv, &mcerror))
{
vfs_shut ();
done_setup ();
g_free (saved_other_dir);
mc_event_deinit (NULL);
goto startup_exit_falure;
}
/* check terminal type
* $TEMR must be set and not empty
* mc_global.tty.xterm_flag is used in init_key() and tty_init()
* Do this after mc_args_handle() where mc_args__force_xterm is set up.
*/
mc_global.tty.xterm_flag = tty_check_term (mc_args__force_xterm);
/* NOTE: This has to be called before tty_init or whatever routine
calls any define_sequence */
init_key ();
/* Must be done before installing the SIGCHLD handler [[FIXME]] */
handle_console (CONSOLE_INIT);
#ifdef ENABLE_SUBSHELL
/* Don't use subshell when invoked as viewer or editor */
if (mc_global.mc_run_mode != MC_RUN_FULL)
mc_global.tty.use_subshell = FALSE;
if (mc_global.tty.use_subshell)
subshell_get_console_attributes ();
#endif /* ENABLE_SUBSHELL */
/* Install the SIGCHLD handler; must be done before init_subshell() */
init_sigchld ();
/* We need this, since ncurses endwin () doesn't restore the signals */
save_stop_handler ();
/* Must be done before init_subshell, to set up the terminal size: */
/* FIXME: Should be removed and LINES and COLS computed on subshell */
tty_init (!mc_args__nomouse, mc_global.tty.xterm_flag);
/* start check mc_global.display_codepage and mc_global.source_codepage */
check_codeset ();
/* Removing this from the X code let's us type C-c */
load_key_defs ();
load_keymap_defs (!mc_args__nokeymap);
macros_list = g_array_new (TRUE, FALSE, sizeof (macros_t));
tty_init_colors (mc_global.tty.disable_colors, mc_args__force_colors);
mc_skin_init (NULL, &mcerror);
dlg_set_default_colors ();
input_set_default_colors ();
if (mc_global.mc_run_mode == MC_RUN_FULL)
command_set_default_colors ();
mc_error_message (&mcerror);
#ifdef ENABLE_SUBSHELL
/* Done here to ensure that the subshell doesn't */
/* inherit the file descriptors opened below, etc */
if (mc_global.tty.use_subshell)
init_subshell ();
#endif /* ENABLE_SUBSHELL */
/* Also done after init_subshell, to save any shell init file messages */
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_SAVE);
if (mc_global.tty.alternate_plus_minus)
application_keypad_mode ();
/* Done after subshell initialization to allow select and paste text by mouse
w/o Shift button in subshell in the native console */
init_mouse ();
/* Done after do_enter_ca_mode (tty_init) because in VTE bracketed mode is
separate for the normal and alternate screens */
enable_bracketed_paste ();
/* subshell_prompt is NULL here */
mc_prompt = (geteuid () == 0) ? "# " : "$ ";
if (config_migrated)
{
message (D_ERROR, _("Warning"), "%s", config_migrate_msg);
g_free (config_migrate_msg);
}
/* Program main loop */
if (mc_global.midnight_shutdown)
exit_code = EXIT_SUCCESS;
else
exit_code = do_nc ()? EXIT_SUCCESS : EXIT_FAILURE;
/* Save the tree store */
(void) tree_store_save ();
free_keymap_defs ();
/* Virtual File System shutdown */
vfs_shut ();
flush_extension_file (); /* does only free memory */
mc_skin_deinit ();
tty_colors_done ();
tty_shutdown ();
done_setup ();
if (mc_global.tty.console_flag != '\0' && (quit & SUBSHELL_EXIT) == 0)
handle_console (CONSOLE_RESTORE);
if (mc_global.tty.alternate_plus_minus)
numeric_keypad_mode ();
(void) signal (SIGCHLD, SIG_DFL); /* Disable the SIGCHLD handler */
if (mc_global.tty.console_flag != '\0')
handle_console (CONSOLE_DONE);
if (mc_global.mc_run_mode == MC_RUN_FULL && mc_args__last_wd_file != NULL
&& last_wd_string != NULL && !print_last_revert)
{
int last_wd_fd;
last_wd_fd = open (mc_args__last_wd_file, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL,
S_IRUSR | S_IWUSR);
if (last_wd_fd != -1)
{
ssize_t ret1;
int ret2;
ret1 = write (last_wd_fd, last_wd_string, strlen (last_wd_string));
ret2 = close (last_wd_fd);
(void) ret1;
(void) ret2;
}
}
g_free (last_wd_string);
g_free (mc_global.tty.shell);
done_key ();
if (macros_list != NULL)
{
guint i;
for (i = 0; i < macros_list->len; i++)
{
macros_t *macros;
macros = &g_array_index (macros_list, struct macros_t, i);
if (macros != NULL && macros->macro != NULL)
(void) g_array_free (macros->macro, FALSE);
}
(void) g_array_free (macros_list, TRUE);
}
/* Tries to raise file lock
Returns 1 on success, 0 on failure, -1 if abort
Warning: Might do screen refresh and lose edit->force */
int
edit_lock_file (char *fname)
{
char *lockfname, *newlock, *msg, *lock;
struct stat statbuf;
struct lock_s *lockinfo;
/* Just to be sure (and don't lock new file) */
if (!fname || !*fname)
return 0;
/* Locking on VFS is not supported */
if (!vfs_file_is_local (fname))
return 0;
/* Check if already locked */
lockfname = g_strconcat (".#", fname, NULL);
if (lstat (lockfname, &statbuf) == 0) {
lock = lock_get_info (lockfname);
if (!lock) {
g_free (lockfname);
return 0;
}
lockinfo = lock_extract_info (lock);
/* Check if locking process alive, ask user if required */
if (!lockinfo->pid
|| !(kill (lockinfo->pid, 0) == -1 && errno == ESRCH)) {
msg =
g_strdup_printf (_
("File \"%s\" is already being edited\n"
"User: %s\nProcess ID: %d"), fname,
lockinfo->who, lockinfo->pid);
/* TODO: Implement "Abort" - needs to rewind undo stack */
switch (edit_query_dialog2
(_("File locked"), msg, _("&Grab lock"),
_("&Ignore lock"))) {
case 0:
break;
case 1:
case -1:
g_free (lockfname);
g_free (msg);
return 0;
}
g_free (msg);
}
unlink (lockfname);
}
/* Create lock symlink */
newlock = lock_build_name (fname);
if (symlink (newlock, lockfname) == -1) {
g_free (lockfname);
g_free (newlock);
return 0;
}
g_free (lockfname);
g_free (newlock);
return 1;
}
void load_setup (void)
{
static char *buffer;
char *profile;
char *inifile;
int i;
#ifdef USE_NETCODE
extern char *ftpfs_proxy_host;
#endif
buffer = concat_dir_and_file (home_dir, PROFILE_NAME);
inifile = concat_dir_and_file (mc_home, "mc.ini");
if (exist_file (buffer)){
profile = buffer;
} else if (exist_file (inifile)){
profile = strdup (inifile);
free (buffer);
} else {
profile = buffer;
}
free (inifile);
profile_name = profile;
/* Load integer boolean options */
for (i = 0; options [i].opt_name; i++)
*options [i].opt_addr =
get_int (profile, options [i].opt_name, *options [i].opt_addr);
load_layout (profile);
load_panelize ();
startup_left_mode = load_mode ("New Left Panel");
startup_right_mode = load_mode ("New Right Panel");
/* At least one of the panels is a listing panel */
if (startup_left_mode != view_listing && startup_right_mode!=view_listing)
startup_left_mode = view_listing;
if (!other_dir){
buffer = (char*) malloc (MC_MAXPATHLEN);
load_string ("Dirs", "other_dir", ".", buffer,
MC_MAXPATHLEN);
if (vfs_file_is_local (buffer))
other_dir = buffer;
else
free (buffer);
}
#ifdef USE_NETCODE
ftpfs_proxy_host = do_load_string ("Misc", "ftp_proxy_host", "gate");
#endif
boot_current_is_left =
GetPrivateProfileInt ("Dirs", "current_is_left", 1, profile);
load_string ("Misc", "find_ignore_dirs", "", setup_color_string,
sizeof (setup_color_string));
if (setup_color_string [0])
find_ignore_dirs = copy_strings (":", setup_color_string, ":", 0);
/* The default color and the terminal dependent color */
load_string ("Colors", "base_color", "", setup_color_string,
sizeof (setup_color_string));
load_string ("Colors", getenv ("TERM"), "",
term_color_string, sizeof (term_color_string));
load_string ("Colors", "color_terminals", "",
color_terminal_string, sizeof (color_terminal_string));
/* Load the directory history */
/* directory_history_load (); */
/* Remove the temporal entries */
profile_clean_section ("Temporal:New Left Panel", profile_name);
profile_clean_section ("Temporal:New Right Panel", profile_name);
#ifdef USE_VFS
#ifdef USE_NETCODE
ftpfs_init_passwd ();
#endif
#endif
}
int
lock_file (const vfs_path_t * fname_vpath)
{
char *lockfname = NULL, *newlock, *msg, *lock;
struct stat statbuf;
struct lock_s *lockinfo;
gboolean is_local;
gboolean symlink_ok = FALSE;
const char *elpath;
if (fname_vpath == NULL)
return 0;
elpath = vfs_path_get_by_index (fname_vpath, 0)->path;
/* Just to be sure (and don't lock new file) */
if (*elpath == '\0')
return 0;
/* Locking on VFS is not supported */
is_local = vfs_file_is_local (fname_vpath);
if (is_local)
{
/* Check if already locked */
lockfname = lock_build_symlink_name (fname_vpath);
}
if (!is_local || lockfname == NULL)
return 0;
if (lstat (lockfname, &statbuf) == 0)
{
lock = lock_get_info (lockfname);
if (lock == NULL)
goto ret;
lockinfo = lock_extract_info (lock);
/* Check if locking process alive, ask user if required */
if (lockinfo->pid == 0 || !(kill (lockinfo->pid, 0) == -1 && errno == ESRCH))
{
msg =
g_strdup_printf (_
("File \"%s\" is already being edited.\n"
"User: %s\nProcess ID: %d"), x_basename (lockfname) + 2,
lockinfo->who, (int) lockinfo->pid);
/* TODO: Implement "Abort" - needs to rewind undo stack */
switch (query_dialog
(_("File locked"), msg, D_NORMAL, 2, _("&Grab lock"), _("&Ignore lock")))
{
case 0:
break;
case 1:
case -1:
g_free (msg);
goto ret;
break; /* FIXME: unneeded? */
}
g_free (msg);
}
unlink (lockfname);
}
/* Create lock symlink */
newlock = lock_build_name ();
symlink_ok = (symlink (newlock, lockfname) != -1);
g_free (newlock);
ret:
g_free (lockfname);
return symlink_ok ? 1 : 0;
}
void
load_setup (void)
{
char *profile;
size_t i;
char *buffer;
const char *kt;
#ifdef HAVE_CHARSET
load_codepages_list ();
#endif /* HAVE_CHARSET */
profile = setup_init ();
/* mc.lib is common for all users, but has priority lower than
${XDG_CONFIG_HOME}/mc/ini. FIXME: it's only used for keys and treestore now */
global_profile_name = g_build_filename (mc_sysconfig_dir, MC_GLOBAL_CONFIG_FILE, (char *) NULL);
if (!exist_file (global_profile_name))
{
g_free (global_profile_name);
global_profile_name = g_build_filename (mc_share_data_dir, MC_GLOBAL_CONFIG_FILE, (char *) NULL);
}
panels_profile_name = g_build_filename (mc_config_get_cache_path (), MC_PANELS_FILE, NULL);
mc_main_config = mc_config_init (profile);
if (!exist_file (panels_profile_name))
setup__move_panels_config_into_separate_file (profile);
mc_panels_config = mc_config_init (panels_profile_name);
/* Load integer boolean options */
for (i = 0; int_options[i].opt_name != NULL; i++)
*int_options[i].opt_addr =
mc_config_get_int (mc_main_config, CONFIG_APP_SECTION, int_options[i].opt_name,
*int_options[i].opt_addr);
if (option_tab_spacing <= 0)
option_tab_spacing = DEFAULT_TAB_SPACING;
#ifdef USE_INTERNAL_EDIT
if (option_word_wrap_line_length <= 0)
option_word_wrap_line_length = DEFAULT_WRAP_LINE_LENGTH;
#endif /* USE_INTERNAL_EDIT */
/* overwrite old_esc_mode_timeout */
kt = getenv ("KEYBOARD_KEY_TIMEOUT_US");
if ((kt != NULL) && (kt[0] != '\0'))
old_esc_mode_timeout = atoi (kt);
/* Load string options */
for (i = 0; str_options[i].opt_name != NULL; i++)
*str_options[i].opt_addr =
mc_config_get_string (mc_main_config, CONFIG_APP_SECTION, str_options[i].opt_name,
str_options[i].opt_defval);
load_layout ();
panels_load_options ();
load_panelize ();
startup_left_mode = setup__load_panel_state ("New Left Panel");
startup_right_mode = setup__load_panel_state ("New Right Panel");
/* At least one of the panels is a listing panel */
if (startup_left_mode != view_listing && startup_right_mode != view_listing)
startup_left_mode = view_listing;
if (mc_run_param1 == NULL)
{
buffer = mc_config_get_string (mc_panels_config, "Dirs", "other_dir", ".");
if (vfs_file_is_local (buffer))
mc_run_param1 = buffer;
else
g_free (buffer);
}
boot_current_is_left = mc_config_get_bool (mc_panels_config, "Dirs", "current_is_left", TRUE);
/* Load time formats */
user_recent_timeformat =
mc_config_get_string (mc_main_config, "Misc", "timeformat_recent", FMTTIME);
user_old_timeformat = mc_config_get_string (mc_main_config, "Misc", "timeformat_old", FMTYEAR);
#ifdef ENABLE_VFS_FTP
ftpfs_proxy_host = mc_config_get_string (mc_main_config, "Misc", "ftp_proxy_host", "gate");
ftpfs_ignore_chattr_errors = mc_config_get_bool (mc_main_config, CONFIG_APP_SECTION,
"ignore_ftp_chattr_errors", TRUE);
ftpfs_init_passwd ();
#endif /* ENABLE_VFS_FTP */
/* The default color and the terminal dependent color */
setup_color_string = mc_config_get_string (mc_main_config, "Colors", "base_color", "");
term_color_string = mc_config_get_string (mc_main_config, "Colors", getenv ("TERM"), "");
color_terminal_string = mc_config_get_string (mc_main_config, "Colors", "color_terminals", "");
/* Load the directory history */
/* directory_history_load (); */
/* Remove the temporal entries */
#ifdef HAVE_CHARSET
if (codepages->len > 1)
{
buffer = mc_config_get_string (mc_main_config, "Misc", "display_codepage", "");
if (buffer[0] != '\0')
{
display_codepage = get_codepage_index (buffer);
cp_display = get_codepage_id (display_codepage);
}
g_free (buffer);
buffer = mc_config_get_string (mc_main_config, "Misc", "source_codepage", "");
if (buffer[0] != '\0')
{
default_source_codepage = get_codepage_index (buffer);
source_codepage = default_source_codepage; /* May be source_codepage doesn't need this */
cp_source = get_codepage_id (source_codepage);
}
g_free (buffer);
}
autodetect_codeset = mc_config_get_string (mc_main_config, "Misc", "autodetect_codeset", "");
if ((autodetect_codeset[0] != '\0') && (strcmp (autodetect_codeset, "off") != 0))
is_autodetect_codeset_enabled = TRUE;
g_free (init_translation_table (source_codepage, display_codepage));
buffer = (char *) get_codepage_id (display_codepage);
if (buffer != NULL)
utf8_display = str_isutf8 (buffer);
#endif /* HAVE_CHARSET */
clipboard_store_path = mc_config_get_string (mc_main_config, "Misc", "clipboard_store", "");
clipboard_paste_path = mc_config_get_string (mc_main_config, "Misc", "clipboard_paste", "");
}
