Adding upstream version 3:4.8.30.upstream/3%4.8.30

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1293 insertions, 0 deletions

diff --git a/lib/utilunix.c b/lib/utilunix.c
new file mode 100644
index 0000000..42e0f6d
--- /dev/null
+++ b/lib/utilunix.c
@@ -0,0 +1,1293 @@
+/*
+   Various utilities - Unix variants
+
+   Copyright (C) 1994-2023
+   Free Software Foundation, Inc.
+
+   Written by:
+   Miguel de Icaza, 1994, 1995, 1996
+   Janne Kukonlehto, 1994, 1995, 1996
+   Dugan Porter, 1994, 1995, 1996
+   Jakub Jelinek, 1994, 1995, 1996
+   Mauricio Plaza, 1994, 1995, 1996
+   Andrew Borodin <aborodin@vmail.ru> 2010-2022
+
+   The mc_realpath routine is mostly from uClibc package, written
+   by Rick Sladkey <jrs@world.std.com>
+
+   This file is part of the Midnight Commander.
+
+   The Midnight Commander is free software: you can redistribute it
+   and/or modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   The Midnight Commander is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/** \file utilunix.c
+ *  \brief Source: various utilities - Unix variant
+ */
+
+#include <config.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#include <sys/wait.h>
+#include <pwd.h>
+#include <grp.h>
+
+#include "lib/global.h"
+
+#include "lib/unixcompat.h"
+#include "lib/vfs/vfs.h"        /* VFS_ENCODING_PREFIX */
+#include "lib/strutil.h"        /* str_move() */
+#include "lib/util.h"
+#include "lib/widget.h"         /* message() */
+#include "lib/vfs/xdirentry.h"
+
+#ifdef HAVE_CHARSET
+#include "lib/charsets.h"
+#endif
+
+#include "utilunix.h"
+
+/*** global variables ****************************************************************************/
+
+struct sigaction startup_handler;
+
+/*** file scope macro definitions ****************************************************************/
+
+#define UID_CACHE_SIZE 200
+#define GID_CACHE_SIZE 30
+
+/*** file scope type declarations ****************************************************************/
+
+typedef struct
+{
+    int index;
+    char *string;
+} int_cache;
+
+typedef enum
+{
+    FORK_ERROR = -1,
+    FORK_CHILD,
+    FORK_PARENT,
+} my_fork_state_t;
+
+typedef struct
+{
+    struct sigaction intr;
+    struct sigaction quit;
+    struct sigaction stop;
+} my_system_sigactions_t;
+
+/*** forward declarations (file scope functions) *************************************************/
+
+/*** file scope variables ************************************************************************/
+
+static int_cache uid_cache[UID_CACHE_SIZE];
+static int_cache gid_cache[GID_CACHE_SIZE];
+
+/* --------------------------------------------------------------------------------------------- */
+/*** file scope functions ************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+
+static char *
+i_cache_match (int id, int_cache * cache, int size)
+{
+    int i;
+
+    for (i = 0; i < size; i++)
+        if (cache[i].index == id)
+            return cache[i].string;
+    return 0;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
+{
+    g_free (cache[*last].string);
+    cache[*last].string = g_strdup (text);
+    cache[*last].index = id;
+    *last = ((*last) + 1) % size;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static my_fork_state_t
+my_fork (void)
+{
+    pid_t pid;
+
+    pid = fork ();
+
+    if (pid < 0)
+    {
+        fprintf (stderr, "\n\nfork () = -1\n");
+        return FORK_ERROR;
+    }
+
+    if (pid == 0)
+        return FORK_CHILD;
+
+    while (TRUE)
+    {
+        int status = 0;
+
+        if (waitpid (pid, &status, 0) > 0)
+            return WEXITSTATUS (status) == 0 ? FORK_PARENT : FORK_ERROR;
+
+        if (errno != EINTR)
+            return FORK_ERROR;
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+my_system__save_sigaction_handlers (my_system_sigactions_t * sigactions)
+{
+    struct sigaction ignore;
+
+    memset (&ignore, 0, sizeof (ignore));
+    ignore.sa_handler = SIG_IGN;
+    sigemptyset (&ignore.sa_mask);
+
+    sigaction (SIGINT, &ignore, &sigactions->intr);
+    sigaction (SIGQUIT, &ignore, &sigactions->quit);
+
+    /* Restore the original SIGTSTP handler, we don't want ncurses' */
+    /* handler messing the screen after the SIGCONT */
+    sigaction (SIGTSTP, &startup_handler, &sigactions->stop);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+my_system__restore_sigaction_handlers (my_system_sigactions_t * sigactions)
+{
+    sigaction (SIGINT, &sigactions->intr, NULL);
+    sigaction (SIGQUIT, &sigactions->quit, NULL);
+    sigaction (SIGTSTP, &sigactions->stop, NULL);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static GPtrArray *
+my_system_make_arg_array (int flags, const char *shell, char **execute_name)
+{
+    GPtrArray *args_array;
+
+    args_array = g_ptr_array_new ();
+
+    if ((flags & EXECUTE_AS_SHELL) != 0)
+    {
+        g_ptr_array_add (args_array, (gpointer) shell);
+        g_ptr_array_add (args_array, (gpointer) "-c");
+        *execute_name = g_strdup (shell);
+    }
+    else
+    {
+        char *shell_token;
+
+        shell_token = shell != NULL ? strchr (shell, ' ') : NULL;
+        if (shell_token == NULL)
+            *execute_name = g_strdup (shell);
+        else
+            *execute_name = g_strndup (shell, (gsize) (shell_token - shell));
+
+        g_ptr_array_add (args_array, (gpointer) shell);
+    }
+    return args_array;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+mc_pread_stream (mc_pipe_stream_t * ps, const fd_set * fds)
+{
+    size_t buf_len;
+    ssize_t read_len;
+
+    if (!FD_ISSET (ps->fd, fds))
+    {
+        ps->len = MC_PIPE_STREAM_UNREAD;
+        return;
+    }
+
+    buf_len = (size_t) ps->len;
+
+    if (buf_len >= MC_PIPE_BUFSIZE)
+        buf_len = ps->null_term ? MC_PIPE_BUFSIZE - 1 : MC_PIPE_BUFSIZE;
+
+    do
+    {
+        read_len = read (ps->fd, ps->buf, buf_len);
+    }
+    while (read_len < 0 && errno == EINTR);
+
+    if (read_len < 0)
+    {
+        /* reading error */
+        ps->len = MC_PIPE_ERROR_READ;
+        ps->error = errno;
+    }
+    else if (read_len == 0)
+        /* EOF */
+        ps->len = MC_PIPE_STREAM_EOF;
+    else
+    {
+        /* success */
+        ps->len = read_len;
+
+        if (ps->null_term)
+            ps->buf[(size_t) ps->len] = '\0';
+    }
+
+    ps->pos = 0;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/*** public functions ****************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+
+const char *
+get_owner (uid_t uid)
+{
+    struct passwd *pwd;
+    char *name;
+    static uid_t uid_last;
+
+    name = i_cache_match ((int) uid, uid_cache, UID_CACHE_SIZE);
+    if (name != NULL)
+        return name;
+
+    pwd = getpwuid (uid);
+    if (pwd != NULL)
+    {
+        i_cache_add ((int) uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, (int *) &uid_last);
+        return pwd->pw_name;
+    }
+    else
+    {
+        static char ibuf[10];
+
+        g_snprintf (ibuf, sizeof (ibuf), "%d", (int) uid);
+        return ibuf;
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+const char *
+get_group (gid_t gid)
+{
+    struct group *grp;
+    char *name;
+    static gid_t gid_last;
+
+    name = i_cache_match ((int) gid, gid_cache, GID_CACHE_SIZE);
+    if (name != NULL)
+        return name;
+
+    grp = getgrgid (gid);
+    if (grp != NULL)
+    {
+        i_cache_add ((int) gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, (int *) &gid_last);
+        return grp->gr_name;
+    }
+    else
+    {
+        static char gbuf[10];
+
+        g_snprintf (gbuf, sizeof (gbuf), "%d", (int) gid);
+        return gbuf;
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/* Since ncurses uses a handler that automatically refreshes the */
+/* screen after a SIGCONT, and we don't want this behavior when */
+/* spawning a child, we save the original handler here */
+
+void
+save_stop_handler (void)
+{
+    sigaction (SIGTSTP, NULL, &startup_handler);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Wrapper for _exit() system call.
+ * The _exit() function has gcc's attribute 'noreturn', and this is reason why we can't
+ * mock the call.
+ *
+ * @param status exit code
+ */
+
+void
+/* __attribute__ ((noreturn)) */
+my_exit (int status)
+{
+    _exit (status);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Call external programs.
+ *
+ * @parameter flags   addition conditions for running external programs.
+ * @parameter shell   shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
+ *                    Shell (or command) will be found in paths described in PATH variable
+ *                    (if shell parameter doesn't begin from path delimiter)
+ * @parameter command Command for shell (or first parameter for command, if flags contain EXECUTE_AS_SHELL)
+ * @return 0 if successful, -1 otherwise
+ */
+
+int
+my_system (int flags, const char *shell, const char *command)
+{
+    return my_systeml (flags, shell, command, NULL);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Call external programs with various parameters number.
+ *
+ * @parameter flags addition conditions for running external programs.
+ * @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
+ *                  Shell (or command) will be found in paths described in PATH variable
+ *                  (if shell parameter doesn't begin from path delimiter)
+ * @parameter ...   Command for shell with addition parameters for shell
+ *                  (or parameters for command, if flags contain EXECUTE_AS_SHELL).
+ *                  Should be NULL terminated.
+ * @return 0 if successful, -1 otherwise
+ */
+
+int
+my_systeml (int flags, const char *shell, ...)
+{
+    GPtrArray *args_array;
+    int status = 0;
+    va_list vargs;
+    char *one_arg;
+
+    args_array = g_ptr_array_new ();
+
+    va_start (vargs, shell);
+    while ((one_arg = va_arg (vargs, char *)) != NULL)
+          g_ptr_array_add (args_array, one_arg);
+    va_end (vargs);
+
+    g_ptr_array_add (args_array, NULL);
+    status = my_systemv_flags (flags, shell, (char *const *) args_array->pdata);
+
+    g_ptr_array_free (args_array, TRUE);
+
+    return status;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Call external programs with array of strings as parameters.
+ *
+ * @parameter command command to run. Command will be found in paths described in PATH variable
+ *                    (if command parameter doesn't begin from path delimiter)
+ * @parameter argv    Array of strings (NULL-terminated) with parameters for command
+ * @return 0 if successful, -1 otherwise
+ */
+
+int
+my_systemv (const char *command, char *const argv[])
+{
+    my_fork_state_t fork_state;
+    int status = 0;
+    my_system_sigactions_t sigactions;
+
+    my_system__save_sigaction_handlers (&sigactions);
+
+    fork_state = my_fork ();
+    switch (fork_state)
+    {
+    case FORK_ERROR:
+        status = -1;
+        break;
+    case FORK_CHILD:
+        {
+            signal (SIGINT, SIG_DFL);
+            signal (SIGQUIT, SIG_DFL);
+            signal (SIGTSTP, SIG_DFL);
+            signal (SIGCHLD, SIG_DFL);
+
+            execvp (command, argv);
+            my_exit (127);      /* Exec error */
+        }
+        MC_FALLTHROUGH;
+        /* no break here, or unreachable-code warning by no returning my_exit() */
+    default:
+        status = 0;
+        break;
+    }
+    my_system__restore_sigaction_handlers (&sigactions);
+
+    return status;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Call external programs with flags and with array of strings as parameters.
+ *
+ * @parameter flags   addition conditions for running external programs.
+ * @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
+ *                    Shell (or command) will be found in paths described in PATH variable
+ *                    (if shell parameter doesn't begin from path delimiter)
+ * @parameter argv    Array of strings (NULL-terminated) with parameters for command
+ * @return 0 if successful, -1 otherwise
+ */
+
+int
+my_systemv_flags (int flags, const char *command, char *const argv[])
+{
+    char *execute_name = NULL;
+    GPtrArray *args_array;
+    int status = 0;
+
+    args_array = my_system_make_arg_array (flags, command, &execute_name);
+
+    for (; argv != NULL && *argv != NULL; argv++)
+        g_ptr_array_add (args_array, *argv);
+
+    g_ptr_array_add (args_array, NULL);
+    status = my_systemv (execute_name, (char *const *) args_array->pdata);
+
+    g_free (execute_name);
+    g_ptr_array_free (args_array, TRUE);
+
+    return status;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Create pipe and run child process.
+ *
+ * @parameter command command line of child process
+ * @parameter read_out do or don't read the stdout of child process
+ * @parameter read_err do or don't read the stderr of child process
+ * @parameter error contains pointer to object to handle error code and message
+ *
+ * @return newly created object of mc_pipe_t class in success, NULL otherwise
+ */
+
+mc_pipe_t *
+mc_popen (const char *command, gboolean read_out, gboolean read_err, GError ** error)
+{
+    mc_pipe_t *p;
+    const char *const argv[] = { "/bin/sh", "sh", "-c", command, NULL };
+
+    p = g_try_new (mc_pipe_t, 1);
+    if (p == NULL)
+    {
+        mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE, "%s",
+                          _("Cannot create pipe descriptor"));
+        goto ret_err;
+    }
+
+    p->out.fd = -1;
+    p->err.fd = -1;
+
+    if (!g_spawn_async_with_pipes
+        (NULL, (gchar **) argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_FILE_AND_ARGV_ZERO, NULL,
+         NULL, &p->child_pid, NULL, read_out ? &p->out.fd : NULL, read_err ? &p->err.fd : NULL,
+         error))
+    {
+        mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE_STREAM, "%s",
+                          _("Cannot create pipe streams"));
+        goto ret_err;
+    }
+
+    p->out.buf[0] = '\0';
+    p->out.len = MC_PIPE_BUFSIZE;
+    p->out.null_term = FALSE;
+
+    p->err.buf[0] = '\0';
+    p->err.len = MC_PIPE_BUFSIZE;
+    p->err.null_term = FALSE;
+
+    return p;
+
+  ret_err:
+    g_free (p);
+    return NULL;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Read stdout and stderr of pipe asynchronously.
+ *
+ * @parameter p pipe descriptor
+ *
+ * The lengths of read data contain in p->out.len and p->err.len.
+ *
+ * Before read, p->xxx.len is an input. It defines the number of data to read.
+ * Should not be greater than MC_PIPE_BUFSIZE.
+ *
+ * After read, p->xxx.len is an output and contains the following:
+ *   p->xxx.len > 0: an actual length of read data stored in p->xxx.buf;
+ *   p->xxx.len == MC_PIPE_STREAM_EOF: EOF of stream p->xxx;
+ *   p->xxx.len == MC_PIPE_STREAM_UNREAD: stream p->xxx was not read;
+ *   p->xxx.len == MC_PIPE_ERROR_READ: reading error, and p->xxx.errno is set appropriately.
+ *
+ * @parameter error contains pointer to object to handle error code and message
+ */
+
+void
+mc_pread (mc_pipe_t * p, GError ** error)
+{
+    gboolean read_out, read_err;
+    fd_set fds;
+    int maxfd = 0;
+    int res;
+
+    if (error != NULL)
+        *error = NULL;
+
+    read_out = p->out.fd >= 0;
+    read_err = p->err.fd >= 0;
+
+    if (!read_out && !read_err)
+    {
+        p->out.len = MC_PIPE_STREAM_UNREAD;
+        p->err.len = MC_PIPE_STREAM_UNREAD;
+        return;
+    }
+
+    FD_ZERO (&fds);
+    if (read_out)
+    {
+        FD_SET (p->out.fd, &fds);
+        maxfd = p->out.fd;
+    }
+
+    if (read_err)
+    {
+        FD_SET (p->err.fd, &fds);
+        maxfd = MAX (maxfd, p->err.fd);
+    }
+
+    /* no timeout */
+    res = select (maxfd + 1, &fds, NULL, NULL, NULL);
+    if (res < 0 && errno != EINTR)
+    {
+        mc_propagate_error (error, MC_PIPE_ERROR_READ,
+                            _
+                            ("Unexpected error in select() reading data from a child process:\n%s"),
+                            unix_error_string (errno));
+        return;
+    }
+
+    if (read_out)
+        mc_pread_stream (&p->out, &fds);
+    else
+        p->out.len = MC_PIPE_STREAM_UNREAD;
+
+    if (read_err)
+        mc_pread_stream (&p->err, &fds);
+    else
+        p->err.len = MC_PIPE_STREAM_UNREAD;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Reads a line from @stream. Reading stops after an EOL or a newline. If a newline is read,
+ * it is appended to the line.
+ *
+ * @stream mc_pipe_stream_t object
+ *
+ * @return newly created GString or NULL in case of EOL;
+ */
+
+GString *
+mc_pstream_get_string (mc_pipe_stream_t * ps)
+{
+    char *s;
+    size_t size, i;
+    gboolean escape = FALSE;
+
+    g_return_val_if_fail (ps != NULL, NULL);
+
+    if (ps->len < 0)
+        return NULL;
+
+    size = ps->len - ps->pos;
+
+    if (size == 0)
+        return NULL;
+
+    s = ps->buf + ps->pos;
+
+    if (s[0] == '\0')
+        return NULL;
+
+    /* find '\0' or unescaped '\n' */
+    for (i = 0; i < size && !(s[i] == '\0' || (s[i] == '\n' && !escape)); i++)
+        escape = s[i] == '\\' ? !escape : FALSE;
+
+    if (i != size && s[i] == '\n')
+        i++;
+
+    ps->pos += i;
+
+    return g_string_new_len (s, i);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Close pipe and destroy pipe descriptor.
+ *
+ * @parameter p pipe descriptor
+ * @parameter error contains pointer to object to handle error code and message
+ */
+
+void
+mc_pclose (mc_pipe_t * p, GError ** error)
+{
+    int res;
+
+    if (p == NULL)
+    {
+        mc_replace_error (error, MC_PIPE_ERROR_READ, "%s",
+                          _("Cannot close pipe descriptor (p == NULL)"));
+        return;
+    }
+
+    if (p->out.fd >= 0)
+        res = close (p->out.fd);
+    if (p->err.fd >= 0)
+        res = close (p->err.fd);
+
+    do
+    {
+        int status;
+
+        res = waitpid (p->child_pid, &status, 0);
+    }
+    while (res < 0 && errno == EINTR);
+
+    if (res < 0)
+        mc_replace_error (error, MC_PIPE_ERROR_READ, _("Unexpected error in waitpid():\n%s"),
+                          unix_error_string (errno));
+
+    g_free (p);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+/**
+ * Perform tilde expansion if possible.
+ *
+ * @param directory pointer to the path
+ *
+ * @return newly allocated string, even if it's unchanged.
+ */
+
+char *
+tilde_expand (const char *directory)
+{
+    struct passwd *passwd;
+    const char *p, *q;
+
+    if (*directory != '~')
+        return g_strdup (directory);
+
+    p = directory + 1;
+
+    /* d = "~" or d = "~/" */
+    if (*p == '\0' || IS_PATH_SEP (*p))
+    {
+        passwd = getpwuid (geteuid ());
+        q = IS_PATH_SEP (*p) ? p + 1 : "";
+    }
+    else
+    {
+        q = strchr (p, PATH_SEP);
+        if (q == NULL)
+            passwd = getpwnam (p);
+        else
+        {
+            char *name;
+
+            name = g_strndup (p, q - p);
+            passwd = getpwnam (name);
+            q++;
+            g_free (name);
+        }
+    }
+
+    /* If we can't figure the user name, leave tilde unexpanded */
+    if (passwd == NULL)
+        return g_strdup (directory);
+
+    return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Canonicalize path.
+ *
+ * @param path path to file
+ * @param flags canonicalization flags
+ *
+ * All modifications of @path are made in place.
+ * Well formed UNC paths are modified only in the local part.
+ */
+
+void
+canonicalize_pathname_custom (char *path, canon_path_flags_t flags)
+{
+    char *p, *s;
+    char *lpath = path;         /* path without leading UNC part */
+    const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
+
+    /* Detect and preserve UNC paths: //server/... */
+    if ((flags & CANON_PATH_GUARDUNC) != 0 && IS_PATH_SEP (path[0]) && IS_PATH_SEP (path[1]))
+    {
+        for (p = path + 2; p[0] != '\0' && !IS_PATH_SEP (p[0]); p++)
+            ;
+        if (IS_PATH_SEP (p[0]) && p > path + 2)
+            lpath = p;
+    }
+
+    if (lpath[0] == '\0' || lpath[1] == '\0')
+        return;
+
+    if ((flags & CANON_PATH_JOINSLASHES) != 0)
+    {
+        /* Collapse multiple slashes */
+        for (p = lpath; *p != '\0'; p++)
+            if (IS_PATH_SEP (p[0]) && IS_PATH_SEP (p[1]) && (p == lpath || *(p - 1) != ':'))
+            {
+                s = p + 1;
+                while (IS_PATH_SEP (*(++s)))
+                    ;
+                str_move (p + 1, s);
+            }
+
+        /* Collapse "/./" -> "/" */
+        for (p = lpath; *p != '\0';)
+            if (IS_PATH_SEP (p[0]) && p[1] == '.' && IS_PATH_SEP (p[2]))
+                str_move (p, p + 2);
+            else
+                p++;
+    }
+
+    if ((flags & CANON_PATH_REMSLASHDOTS) != 0)
+    {
+        size_t len;
+
+        /* Remove trailing slashes */
+        for (p = lpath + strlen (lpath) - 1; p > lpath && IS_PATH_SEP (*p); p--)
+        {
+            if (p >= lpath + url_delim_len - 1
+                && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
+                break;
+            *p = '\0';
+        }
+
+        /* Remove leading "./" */
+        if (lpath[0] == '.' && IS_PATH_SEP (lpath[1]))
+        {
+            if (lpath[2] == '\0')
+            {
+                lpath[1] = '\0';
+                return;
+            }
+
+            str_move (lpath, lpath + 2);
+        }
+
+        /* Remove trailing "/" or "/." */
+        len = strlen (lpath);
+        if (len < 2)
+            return;
+
+        if (IS_PATH_SEP (lpath[len - 1])
+            && (len < url_delim_len
+                || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
+                            url_delim_len) != 0))
+            lpath[len - 1] = '\0';
+        else if (lpath[len - 1] == '.' && IS_PATH_SEP (lpath[len - 2]))
+        {
+            if (len == 2)
+            {
+                lpath[1] = '\0';
+                return;
+            }
+
+            lpath[len - 2] = '\0';
+        }
+    }
+
+    /* Collapse "/.." with the previous part of path */
+    if ((flags & CANON_PATH_REMDOUBLEDOTS) != 0)
+    {
+#ifdef HAVE_CHARSET
+        const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
+#endif /* HAVE_CHARSET */
+
+        for (p = lpath; p[0] != '\0' && p[1] != '\0' && p[2] != '\0';)
+        {
+            if (!IS_PATH_SEP (p[0]) || p[1] != '.' || p[2] != '.'
+                || (!IS_PATH_SEP (p[3]) && p[3] != '\0'))
+            {
+                p++;
+                continue;
+            }
+
+            /* search for the previous token */
+            s = p - 1;
+            if (s >= lpath + url_delim_len - 2
+                && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
+            {
+                s -= (url_delim_len - 2);
+                while (s >= lpath && !IS_PATH_SEP (*s--))
+                    ;
+            }
+
+            while (s >= lpath)
+            {
+                if (s - url_delim_len > lpath
+                    && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
+                {
+                    char *vfs_prefix = s - url_delim_len;
+                    vfs_class *vclass;
+
+                    while (vfs_prefix > lpath && !IS_PATH_SEP (*--vfs_prefix))
+                        ;
+                    if (IS_PATH_SEP (*vfs_prefix))
+                        vfs_prefix++;
+                    *(s - url_delim_len) = '\0';
+
+                    vclass = vfs_prefix_to_class (vfs_prefix);
+                    *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
+
+                    if (vclass != NULL && (vclass->flags & VFSF_REMOTE) != 0)
+                    {
+                        s = vfs_prefix;
+                        continue;
+                    }
+                }
+
+                if (IS_PATH_SEP (*s))
+                    break;
+
+                s--;
+            }
+
+            s++;
+
+            /* If the previous token is "..", we cannot collapse it */
+            if (s[0] == '.' && s[1] == '.' && s + 2 == p)
+            {
+                p += 3;
+                continue;
+            }
+
+            if (p[3] != '\0')
+            {
+                if (s == lpath && IS_PATH_SEP (*s))
+                {
+                    /* "/../foo" -> "/foo" */
+                    str_move (s + 1, p + 4);
+                }
+                else
+                {
+                    /* "token/../foo" -> "foo" */
+#ifdef HAVE_CHARSET
+                    if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
+                        && (is_supported_encoding (s + enc_prefix_len)))
+                        /* special case: remove encoding */
+                        str_move (s, p + 1);
+                    else
+#endif /* HAVE_CHARSET */
+                        str_move (s, p + 4);
+                }
+
+                p = s > lpath ? s - 1 : s;
+                continue;
+            }
+
+            /* trailing ".." */
+            if (s == lpath)
+            {
+                /* "token/.." -> "." */
+                if (!IS_PATH_SEP (lpath[0]))
+                    lpath[0] = '.';
+                lpath[1] = '\0';
+            }
+            else
+            {
+                /* "foo/token/.." -> "foo" */
+                if (s == lpath + 1)
+                    s[0] = '\0';
+#ifdef HAVE_CHARSET
+                else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
+                         && (is_supported_encoding (s + enc_prefix_len)))
+                {
+                    /* special case: remove encoding */
+                    s[0] = '.';
+                    s[1] = '.';
+                    s[2] = '\0';
+
+                    /* search for the previous token */
+                    /* IS_PATH_SEP (s[-1]) */
+                    for (p = s - 1; p >= lpath && !IS_PATH_SEP (*p); p--)
+                        ;
+
+                    if (p >= lpath)
+                        continue;
+                }
+#endif /* HAVE_CHARSET */
+                else
+                {
+                    if (s >= lpath + url_delim_len
+                        && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
+                        *s = '\0';
+                    else
+                        s[-1] = '\0';
+                }
+            }
+
+            break;
+        }
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+char *
+mc_realpath (const char *path, char *resolved_path)
+{
+#ifdef HAVE_CHARSET
+    const char *p = path;
+    gboolean absolute_path = FALSE;
+
+    if (IS_PATH_SEP (*p))
+    {
+        absolute_path = TRUE;
+        p++;
+    }
+
+    /* ignore encoding: skip "#enc:" */
+    if (g_str_has_prefix (p, VFS_ENCODING_PREFIX))
+    {
+        p += strlen (VFS_ENCODING_PREFIX);
+        p = strchr (p, PATH_SEP);
+        if (p != NULL)
+        {
+            if (!absolute_path && p[1] != '\0')
+                p++;
+
+            path = p;
+        }
+    }
+#endif /* HAVE_CHARSET */
+
+#ifdef HAVE_REALPATH
+    return realpath (path, resolved_path);
+#else
+    {
+        char copy_path[PATH_MAX];
+        char got_path[PATH_MAX];
+        char *new_path = got_path;
+        char *max_path;
+#ifdef S_IFLNK
+        char link_path[PATH_MAX];
+        int readlinks = 0;
+        int n;
+#endif /* S_IFLNK */
+
+        /* Make a copy of the source path since we may need to modify it. */
+        if (strlen (path) >= PATH_MAX - 2)
+        {
+            errno = ENAMETOOLONG;
+            return NULL;
+        }
+
+        strcpy (copy_path, path);
+        path = copy_path;
+        max_path = copy_path + PATH_MAX - 2;
+        /* If it's a relative pathname use getwd for starters. */
+        if (!IS_PATH_SEP (*path))
+        {
+            new_path = g_get_current_dir ();
+            if (new_path == NULL)
+                strcpy (got_path, "");
+            else
+            {
+                g_snprintf (got_path, sizeof (got_path), "%s", new_path);
+                g_free (new_path);
+                new_path = got_path;
+            }
+
+            new_path += strlen (got_path);
+            if (!IS_PATH_SEP (new_path[-1]))
+                *new_path++ = PATH_SEP;
+        }
+        else
+        {
+            *new_path++ = PATH_SEP;
+            path++;
+        }
+        /* Expand each slash-separated pathname component. */
+        while (*path != '\0')
+        {
+            /* Ignore stray "/". */
+            if (IS_PATH_SEP (*path))
+            {
+                path++;
+                continue;
+            }
+            if (*path == '.')
+            {
+                /* Ignore ".". */
+                if (path[1] == '\0' || IS_PATH_SEP (path[1]))
+                {
+                    path++;
+                    continue;
+                }
+                if (path[1] == '.')
+                {
+                    if (path[2] == '\0' || IS_PATH_SEP (path[2]))
+                    {
+                        path += 2;
+                        /* Ignore ".." at root. */
+                        if (new_path == got_path + 1)
+                            continue;
+                        /* Handle ".." by backing up. */
+                        while (!IS_PATH_SEP ((--new_path)[-1]))
+                            ;
+                        continue;
+                    }
+                }
+            }
+            /* Safely copy the next pathname component. */
+            while (*path != '\0' && !IS_PATH_SEP (*path))
+            {
+                if (path > max_path)
+                {
+                    errno = ENAMETOOLONG;
+                    return NULL;
+                }
+                *new_path++ = *path++;
+            }
+#ifdef S_IFLNK
+            /* Protect against infinite loops. */
+            if (readlinks++ > MAXSYMLINKS)
+            {
+                errno = ELOOP;
+                return NULL;
+            }
+            /* See if latest pathname component is a symlink. */
+            *new_path = '\0';
+            n = readlink (got_path, link_path, PATH_MAX - 1);
+            if (n < 0)
+            {
+                /* EINVAL means the file exists but isn't a symlink. */
+                if (errno != EINVAL)
+                {
+                    /* Make sure it's null terminated. */
+                    *new_path = '\0';
+                    strcpy (resolved_path, got_path);
+                    return NULL;
+                }
+            }
+            else
+            {
+                /* Note: readlink doesn't add the null byte. */
+                link_path[n] = '\0';
+                if (IS_PATH_SEP (*link_path))
+                    /* Start over for an absolute symlink. */
+                    new_path = got_path;
+                else
+                    /* Otherwise back up over this component. */
+                    while (!IS_PATH_SEP (*(--new_path)))
+                        ;
+                /* Safe sex check. */
+                if (strlen (path) + n >= PATH_MAX - 2)
+                {
+                    errno = ENAMETOOLONG;
+                    return NULL;
+                }
+                /* Insert symlink contents into path. */
+                strcat (link_path, path);
+                strcpy (copy_path, link_path);
+                path = copy_path;
+            }
+#endif /* S_IFLNK */
+            *new_path++ = PATH_SEP;
+        }
+        /* Delete trailing slash but don't whomp a lone slash. */
+        if (new_path != got_path + 1 && IS_PATH_SEP (new_path[-1]))
+            new_path--;
+        /* Make sure it's null terminated. */
+        *new_path = '\0';
+        strcpy (resolved_path, got_path);
+        return resolved_path;
+    }
+#endif /* HAVE_REALPATH */
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Return the index of the permissions triplet
+ *
+ */
+
+int
+get_user_permissions (struct stat *st)
+{
+    static gboolean initialized = FALSE;
+    static gid_t *groups;
+    static int ngroups;
+    static uid_t uid;
+    int i;
+
+    if (!initialized)
+    {
+        uid = geteuid ();
+
+        ngroups = getgroups (0, NULL);
+        if (ngroups == -1)
+            ngroups = 0;        /* ignore errors */
+
+        /* allocate space for one element in addition to what
+         * will be filled by getgroups(). */
+        groups = g_new (gid_t, ngroups + 1);
+
+        if (ngroups != 0)
+        {
+            ngroups = getgroups (ngroups, groups);
+            if (ngroups == -1)
+                ngroups = 0;    /* ignore errors */
+        }
+
+        /* getgroups() may or may not return the effective group ID,
+         * so we always include it at the end of the list. */
+        groups[ngroups++] = getegid ();
+
+        initialized = TRUE;
+    }
+
+    if (st->st_uid == uid || uid == 0)
+        return 0;
+
+    for (i = 0; i < ngroups; i++)
+        if (st->st_gid == groups[i])
+            return 1;
+
+    return 2;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Build filename from arguments.
+ * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
+ */
+
+char *
+mc_build_filenamev (const char *first_element, va_list args)
+{
+    gboolean absolute;
+    const char *element = first_element;
+    GString *path;
+    char *ret;
+
+    if (element == NULL)
+        return NULL;
+
+    path = g_string_new ("");
+
+    absolute = IS_PATH_SEP (*first_element);
+
+    do
+    {
+        if (*element == '\0')
+            element = va_arg (args, char *);
+        else
+        {
+            char *tmp_element;
+            size_t len;
+            const char *start;
+
+            tmp_element = g_strdup (element);
+
+            element = va_arg (args, char *);
+
+            canonicalize_pathname (tmp_element);
+            len = strlen (tmp_element);
+            start = IS_PATH_SEP (tmp_element[0]) ? tmp_element + 1 : tmp_element;
+
+            g_string_append (path, start);
+            if (!IS_PATH_SEP (tmp_element[len - 1]) && element != NULL)
+                g_string_append_c (path, PATH_SEP);
+
+            g_free (tmp_element);
+        }
+    }
+    while (element != NULL);
+
+    if (absolute)
+        g_string_prepend_c (path, PATH_SEP);
+
+    ret = g_string_free (path, FALSE);
+    canonicalize_pathname (ret);
+
+    return ret;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * Build filename from arguments.
+ * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
+ */
+
+char *
+mc_build_filename (const char *first_element, ...)
+{
+    va_list args;
+    char *ret;
+
+    if (first_element == NULL)
+        return NULL;
+
+    va_start (args, first_element);
+    ret = mc_build_filenamev (first_element, args);
+    va_end (args);
+    return ret;
+}
+
+/* --------------------------------------------------------------------------------------------- */