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, 941 insertions, 0 deletions

diff --git a/src/filemanager/treestore.c b/src/filemanager/treestore.c
new file mode 100644
index 0000000..2d23c93
--- /dev/null
+++ b/src/filemanager/treestore.c
@@ -0,0 +1,941 @@
+/*
+   Tree Store
+   Contains a storage of the file system tree representation
+
+   This module has been converted to be a widget.
+
+   The program load and saves the tree each time the tree widget is
+   created and destroyed.  This is required for the future vfs layer,
+   it will be possible to have tree views over virtual file systems.
+
+   Copyright (C) 1999-2023
+   Free Software Foundation, Inc.
+
+   Written by:
+   Janne Kukonlehto, 1994, 1996
+   Norbert Warmuth, 1997
+   Miguel de Icaza, 1996, 1999
+   Slava Zanko <slavazanko@gmail.com>, 2013
+   Andrew Borodin <aborodin@vmail.ru>, 2013
+
+   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 treestore.c
+ *  \brief Source: tree store
+ *
+ *  Contains a storage of the file system tree representation.
+ */
+
+#include <config.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "lib/global.h"
+#include "lib/mcconfig.h"
+#include "lib/vfs/vfs.h"
+#include "lib/fileloc.h"
+#include "lib/strescape.h"
+#include "lib/hook.h"
+#include "lib/util.h"
+
+#include "src/setup.h"          /* setup_init() */
+
+#include "treestore.h"
+
+/*** global variables ****************************************************************************/
+
+/*** file scope macro definitions ****************************************************************/
+
+#define TREE_SIGNATURE "Midnight Commander TreeStore v 2.0"
+
+/*** file scope type declarations ****************************************************************/
+
+/*** forward declarations (file scope functions) *************************************************/
+
+static tree_entry *tree_store_add_entry (const vfs_path_t * name);
+
+/*** file scope variables ************************************************************************/
+
+static struct TreeStore ts;
+
+static hook_t *remove_entry_hooks;
+
+/* --------------------------------------------------------------------------------------------- */
+/*** file scope functions ************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+
+static inline void
+tree_store_dirty (gboolean dirty)
+{
+    ts.dirty = dirty;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+  *
+  * @return the number of common bytes in the strings.
+  */
+
+static size_t
+str_common (const vfs_path_t * s1_vpath, const vfs_path_t * s2_vpath)
+{
+    size_t result = 0;
+    const char *s1, *s2;
+
+    s1 = vfs_path_as_str (s1_vpath);
+    s2 = vfs_path_as_str (s2_vpath);
+
+    while (*s1 != '\0' && *s2 != '\0' && *s1++ == *s2++)
+        result++;
+
+    return result;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** The directory names are arranged in a single linked list in the same
+  * order as they are displayed. When the tree is displayed the expected
+  * order is like this:
+  * /
+  * /bin
+  * /etc
+  * /etc/X11
+  * /etc/rc.d
+  * /etc.old/X11
+  * /etc.old/rc.d
+  * /usr
+  *
+  * i.e. the required collating sequence when comparing two directory names is 
+  * '\0' < PATH_SEP < all-other-characters-in-encoding-order
+  *
+  * Since strcmp doesn't fulfil this requirement we use pathcmp when
+  * inserting directory names into the list. The meaning of the return value 
+  * of pathcmp and strcmp are the same (an integer less than, equal to, or 
+  * greater than zero if p1 is found to be less than, to match, or be greater 
+  * than p2.
+ */
+
+static int
+pathcmp (const vfs_path_t * p1_vpath, const vfs_path_t * p2_vpath)
+{
+    int ret_val;
+    const char *p1, *p2;
+
+    p1 = vfs_path_as_str (p1_vpath);
+    p2 = vfs_path_as_str (p2_vpath);
+
+    for (; *p1 == *p2; p1++, p2++)
+        if (*p1 == '\0')
+            return 0;
+
+    if (*p1 == '\0')
+        ret_val = -1;
+    else if (*p2 == '\0')
+        ret_val = 1;
+    else if (IS_PATH_SEP (*p1))
+        ret_val = -1;
+    else if (IS_PATH_SEP (*p2))
+        ret_val = 1;
+    else
+        ret_val = (*p1 - *p2);
+
+    return ret_val;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static char *
+decode (char *buffer)
+{
+    char *res, *p, *q;
+
+    res = g_strdup (buffer);
+
+    for (p = q = res; *p != '\0'; p++, q++)
+    {
+        if (*p == '\n')
+        {
+            *q = '\0';
+            return res;
+        }
+
+        if (*p != '\\')
+        {
+            *q = *p;
+            continue;
+        }
+
+        p++;
+
+        switch (*p)
+        {
+        case 'n':
+            *q = '\n';
+            break;
+        case '\\':
+            *q = '\\';
+            break;
+        default:
+            break;
+        }
+    }
+
+    *q = *p;
+
+    return res;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** Loads the tree store from the specified filename */
+
+static int
+tree_store_load_from (const char *name)
+{
+    FILE *file;
+    char buffer[MC_MAXPATHLEN + 20];
+
+    g_return_val_if_fail (name != NULL, 0);
+
+    if (ts.loaded)
+        return 1;
+
+    file = fopen (name, "r");
+
+    if (file != NULL
+        && (fgets (buffer, sizeof (buffer), file) == NULL
+            || strncmp (buffer, TREE_SIGNATURE, strlen (TREE_SIGNATURE)) != 0))
+    {
+        fclose (file);
+        file = NULL;
+    }
+
+    if (file != NULL)
+    {
+        char oldname[MC_MAXPATHLEN] = "\0";
+
+        ts.loaded = TRUE;
+
+        /* File open -> read contents */
+        while (fgets (buffer, MC_MAXPATHLEN, file))
+        {
+            tree_entry *e;
+            gboolean scanned;
+            char *lc_name;
+
+            /* Skip invalid records */
+            if (buffer[0] != '0' && buffer[0] != '1')
+                continue;
+
+            if (buffer[1] != ':')
+                continue;
+
+            scanned = buffer[0] == '1';
+
+            lc_name = decode (buffer + 2);
+            if (!IS_PATH_SEP (lc_name[0]))
+            {
+                /* Clear-text decompression */
+                char *s;
+
+                s = strtok (lc_name, " ");
+                if (s != NULL)
+                {
+                    char *different;
+                    int common;
+
+                    common = atoi (s);
+                    different = strtok (NULL, "");
+                    if (different != NULL)
+                    {
+                        vfs_path_t *vpath;
+
+                        vpath = vfs_path_from_str (oldname);
+                        g_strlcpy (oldname + common, different, sizeof (oldname) - (size_t) common);
+                        if (vfs_file_is_local (vpath))
+                        {
+                            vfs_path_t *tmp_vpath;
+
+                            tmp_vpath = vfs_path_from_str (oldname);
+                            e = tree_store_add_entry (tmp_vpath);
+                            vfs_path_free (tmp_vpath, TRUE);
+                            e->scanned = scanned;
+                        }
+                        vfs_path_free (vpath, TRUE);
+                    }
+                }
+            }
+            else
+            {
+                vfs_path_t *vpath;
+
+                vpath = vfs_path_from_str (lc_name);
+                if (vfs_file_is_local (vpath))
+                {
+                    e = tree_store_add_entry (vpath);
+                    e->scanned = scanned;
+                }
+                vfs_path_free (vpath, TRUE);
+                g_strlcpy (oldname, lc_name, sizeof (oldname));
+            }
+            g_free (lc_name);
+        }
+
+        fclose (file);
+    }
+
+    /* Nothing loaded, we add some standard directories */
+    if (!ts.tree_first)
+    {
+        vfs_path_t *tmp_vpath;
+
+        tmp_vpath = vfs_path_from_str (PATH_SEP_STR);
+        tree_store_add_entry (tmp_vpath);
+        tree_store_rescan (tmp_vpath);
+        vfs_path_free (tmp_vpath, TRUE);
+        ts.loaded = TRUE;
+    }
+
+    return 1;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static char *
+encode (const vfs_path_t * vpath, size_t offset)
+{
+    return strutils_escape (vfs_path_as_str (vpath) + offset, -1, "\n\\", FALSE);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** Saves the tree to the specified filename */
+
+static int
+tree_store_save_to (char *name)
+{
+    tree_entry *current;
+    FILE *file;
+
+    file = fopen (name, "w");
+    if (file == NULL)
+        return errno;
+
+    fprintf (file, "%s\n", TREE_SIGNATURE);
+
+    for (current = ts.tree_first; current != NULL; current = current->next)
+        if (vfs_file_is_local (current->name))
+        {
+            int i, common;
+
+            /* Clear-text compression */
+            if (current->prev != NULL
+                && (common = str_common (current->prev->name, current->name)) > 2)
+            {
+                char *encoded;
+
+                encoded = encode (current->name, common);
+                i = fprintf (file, "%d:%d %s\n", current->scanned ? 1 : 0, common, encoded);
+                g_free (encoded);
+            }
+            else
+            {
+                char *encoded;
+
+                encoded = encode (current->name, 0);
+                i = fprintf (file, "%d:%s\n", current->scanned ? 1 : 0, encoded);
+                g_free (encoded);
+            }
+
+            if (i == EOF)
+            {
+                fprintf (stderr, _("Cannot write to the %s file:\n%s\n"),
+                         name, unix_error_string (errno));
+                break;
+            }
+        }
+
+    tree_store_dirty (FALSE);
+    fclose (file);
+
+    return 0;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static tree_entry *
+tree_store_add_entry (const vfs_path_t * name)
+{
+    int flag = -1;
+    tree_entry *current;
+    tree_entry *old = NULL;
+    tree_entry *new;
+    int submask = 0;
+
+    if (ts.tree_last != NULL && ts.tree_last->next != NULL)
+        abort ();
+
+    /* Search for the correct place */
+    for (current = ts.tree_first;
+         current != NULL && (flag = pathcmp (current->name, name)) < 0; current = current->next)
+        old = current;
+
+    if (flag == 0)
+        return current;         /* Already in the list */
+
+    /* Not in the list -> add it */
+    new = g_new0 (tree_entry, 1);
+    if (current == NULL)
+    {
+        /* Append to the end of the list */
+        if (ts.tree_first == NULL)
+        {
+            /* Empty list */
+            ts.tree_first = new;
+            new->prev = NULL;
+        }
+        else
+        {
+            if (old != NULL)
+                old->next = new;
+            new->prev = old;
+        }
+        new->next = NULL;
+        ts.tree_last = new;
+    }
+    else
+    {
+        /* Insert in to the middle of the list */
+        new->prev = old;
+        if (old != NULL)
+        {
+            /* Yes, in the middle */
+            new->next = old->next;
+            old->next = new;
+        }
+        else
+        {
+            /* Nope, in the beginning of the list */
+            new->next = ts.tree_first;
+            ts.tree_first = new;
+        }
+        new->next->prev = new;
+    }
+
+    /* Calculate attributes */
+    new->name = vfs_path_clone (name);
+    new->sublevel = vfs_path_tokens_count (new->name);
+
+    {
+        const char *new_name;
+
+        new_name = vfs_path_get_last_path_str (new->name);
+        new->subname = strrchr (new_name, PATH_SEP);
+        if (new->subname == NULL)
+            new->subname = new_name;
+        else
+            new->subname++;
+    }
+
+    if (new->next != NULL)
+        submask = new->next->submask;
+
+    submask |= 1 << new->sublevel;
+    submask &= (2 << new->sublevel) - 1;
+    new->submask = submask;
+    new->mark = FALSE;
+
+    /* Correct the submasks of the previous entries */
+    for (current = new->prev;
+         current != NULL && current->sublevel > new->sublevel; current = current->prev)
+        current->submask |= 1 << new->sublevel;
+
+    tree_store_dirty (TRUE);
+    return new;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+tree_store_notify_remove (tree_entry * entry)
+{
+    hook_t *p;
+
+    for (p = remove_entry_hooks; p != NULL; p = p->next)
+    {
+        tree_store_remove_fn r = (tree_store_remove_fn) p->hook_fn;
+
+        r (entry, p->hook_data);
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static tree_entry *
+remove_entry (tree_entry * entry)
+{
+    tree_entry *current = entry->prev;
+    long submask = 0;
+    tree_entry *ret = NULL;
+
+    tree_store_notify_remove (entry);
+
+    /* Correct the submasks of the previous entries */
+    if (entry->next != NULL)
+        submask = entry->next->submask;
+
+    for (; current != NULL && current->sublevel > entry->sublevel; current = current->prev)
+    {
+        submask |= 1 << current->sublevel;
+        submask &= (2 << current->sublevel) - 1;
+        current->submask = submask;
+    }
+
+    /* Unlink the entry from the list */
+    if (entry->prev != NULL)
+        entry->prev->next = entry->next;
+    else
+        ts.tree_first = entry->next;
+
+    if (entry->next != NULL)
+        entry->next->prev = entry->prev;
+    else
+        ts.tree_last = entry->prev;
+
+    /* Free the memory used by the entry */
+    vfs_path_free (entry->name, TRUE);
+    g_free (entry);
+
+    return ret;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+process_special_dirs (GList ** special_dirs, const char *file)
+{
+    gchar **start_buff;
+    mc_config_t *cfg;
+
+    cfg = mc_config_init (file, TRUE);
+    if (cfg == NULL)
+        return;
+
+    start_buff = mc_config_get_string_list (cfg, "Special dirs", "list", NULL);
+    if (start_buff != NULL)
+    {
+        gchar **buffers;
+
+        for (buffers = start_buff; *buffers != NULL; buffers++)
+        {
+            *special_dirs = g_list_prepend (*special_dirs, *buffers);
+            *buffers = NULL;
+        }
+
+        g_strfreev (start_buff);
+    }
+    mc_config_deinit (cfg);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static gboolean
+should_skip_directory (const vfs_path_t * vpath)
+{
+    static GList *special_dirs = NULL;
+    GList *l;
+    static gboolean loaded = FALSE;
+    gboolean ret = FALSE;
+
+    if (!loaded)
+    {
+        const char *profile_name;
+
+        profile_name = setup_init ();
+        process_special_dirs (&special_dirs, profile_name);
+        process_special_dirs (&special_dirs, mc_global.profile_name);
+
+        loaded = TRUE;
+    }
+
+    for (l = special_dirs; l != NULL; l = g_list_next (l))
+        if (strncmp (vfs_path_as_str (vpath), l->data, strlen (l->data)) == 0)
+        {
+            ret = TRUE;
+            break;
+        }
+
+    return ret;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+static void
+queue_vpath_free (gpointer data)
+{
+    vfs_path_free ((vfs_path_t *) data, TRUE);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/*** public functions ****************************************************************************/
+/* --------------------------------------------------------------------------------------------- */
+
+/* Searches for specified directory */
+tree_entry *
+tree_store_whereis (const vfs_path_t * name)
+{
+    tree_entry *current;
+    int flag = -1;
+
+    for (current = ts.tree_first;
+         current != NULL && (flag = pathcmp (current->name, name)) < 0; current = current->next)
+        ;
+
+    return flag == 0 ? current : NULL;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+struct TreeStore *
+tree_store_get (void)
+{
+    return &ts;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * \fn int tree_store_load(void)
+ * \brief Loads the tree from the default location
+ * \return 1 if success (true), 0 otherwise (false)
+ */
+
+int
+tree_store_load (void)
+{
+    char *name;
+    int retval;
+
+    name = mc_config_get_full_path (MC_TREESTORE_FILE);
+    retval = tree_store_load_from (name);
+    g_free (name);
+
+    return retval;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/**
+ * \fn int tree_store_save(void)
+ * \brief Saves the tree to the default file in an atomic fashion
+ * \return 0 if success, errno on error
+ */
+
+int
+tree_store_save (void)
+{
+    char *name;
+    int retval;
+
+    name = mc_config_get_full_path (MC_TREESTORE_FILE);
+    mc_util_make_backup_if_possible (name, ".tmp");
+
+    retval = tree_store_save_to (name);
+    if (retval != 0)
+        mc_util_restore_from_backup_if_possible (name, ".tmp");
+    else
+        mc_util_unlink_backup_if_possible (name, ".tmp");
+
+    g_free (name);
+    return retval;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+tree_store_add_entry_remove_hook (tree_store_remove_fn callback, void *data)
+{
+    add_hook (&remove_entry_hooks, (void (*)(void *)) callback, data);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+tree_store_remove_entry_remove_hook (tree_store_remove_fn callback)
+{
+    delete_hook (&remove_entry_hooks, (void (*)(void *)) callback);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+void
+tree_store_remove_entry (const vfs_path_t * name_vpath)
+{
+    tree_entry *current, *base;
+    size_t len;
+
+    g_return_if_fail (name_vpath != NULL);
+
+    /* Miguel Ugly hack */
+    {
+        gboolean is_root;
+        const char *name_vpath_str;
+
+        name_vpath_str = vfs_path_as_str (name_vpath);
+        is_root = (IS_PATH_SEP (name_vpath_str[0]) && name_vpath_str[1] == '\0');
+        if (is_root)
+            return;
+    }
+    /* Miguel Ugly hack end */
+
+    base = tree_store_whereis (name_vpath);
+    if (base == NULL)
+        return;                 /* Doesn't exist */
+
+    len = vfs_path_len (base->name);
+    current = base->next;
+    while (current != NULL && vfs_path_equal_len (current->name, base->name, len))
+    {
+        gboolean ok;
+        tree_entry *old;
+        const char *cname;
+
+        cname = vfs_path_as_str (current->name);
+        ok = (cname[len] == '\0' || IS_PATH_SEP (cname[len]));
+        if (!ok)
+            break;
+
+        old = current;
+        current = current->next;
+        remove_entry (old);
+    }
+    remove_entry (base);
+    tree_store_dirty (TRUE);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** This subdirectory exists -> clear deletion mark */
+
+void
+tree_store_mark_checked (const char *subname)
+{
+    vfs_path_t *name;
+    tree_entry *current, *base;
+    int flag = 1;
+    const char *cname;
+
+    if (!ts.loaded)
+        return;
+
+    if (ts.check_name == NULL)
+        return;
+
+    /* Calculate the full name of the subdirectory */
+    if (DIR_IS_DOT (subname) || DIR_IS_DOTDOT (subname))
+        return;
+
+    cname = vfs_path_as_str (ts.check_name);
+    if (IS_PATH_SEP (cname[0]) && cname[1] == '\0')
+        name = vfs_path_build_filename (PATH_SEP_STR, subname, (char *) NULL);
+    else
+        name = vfs_path_append_new (ts.check_name, subname, (char *) NULL);
+
+    /* Search for the subdirectory */
+    for (current = ts.check_start;
+         current != NULL && (flag = pathcmp (current->name, name)) < 0; current = current->next)
+        ;
+
+    if (flag != 0)
+    {
+        /* Doesn't exist -> add it */
+        current = tree_store_add_entry (name);
+        ts.add_queue_vpath = g_list_prepend (ts.add_queue_vpath, name);
+    }
+    else
+        vfs_path_free (name, TRUE);
+
+    /* Clear the deletion mark from the subdirectory and its children */
+    base = current;
+    if (base != NULL)
+    {
+        size_t len;
+
+        len = vfs_path_len (base->name);
+        base->mark = FALSE;
+        for (current = base->next;
+             current != NULL && vfs_path_equal_len (current->name, base->name, len);
+             current = current->next)
+        {
+            gboolean ok;
+
+            cname = vfs_path_as_str (current->name);
+            ok = (cname[len] == '\0' || IS_PATH_SEP (cname[len]) || len == 1);
+            if (!ok)
+                break;
+
+            current->mark = FALSE;
+        }
+    }
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** Mark the subdirectories of the current directory for delete */
+
+tree_entry *
+tree_store_start_check (const vfs_path_t * vpath)
+{
+    tree_entry *current, *retval;
+    size_t len;
+
+    if (!ts.loaded)
+        return NULL;
+
+    g_return_val_if_fail (ts.check_name == NULL, NULL);
+    ts.check_start = NULL;
+
+    /* Search for the start of subdirectories */
+    current = tree_store_whereis (vpath);
+    if (current == NULL)
+    {
+        struct stat s;
+
+        if (mc_stat (vpath, &s) == -1 || !S_ISDIR (s.st_mode))
+            return NULL;
+
+        current = tree_store_add_entry (vpath);
+        ts.check_name = vfs_path_clone (vpath);
+
+        return current;
+    }
+
+    ts.check_name = vfs_path_clone (vpath);
+
+    retval = current;
+
+    /* Mark old subdirectories for delete */
+    ts.check_start = current->next;
+    len = vfs_path_len (ts.check_name);
+
+    for (current = ts.check_start;
+         current != NULL && vfs_path_equal_len (current->name, ts.check_name, len);
+         current = current->next)
+    {
+        gboolean ok;
+        const char *cname;
+
+        cname = vfs_path_as_str (current->name);
+        ok = (cname[len] == '\0' || IS_PATH_SEP (cname[len]) || len == 1);
+        if (!ok)
+            break;
+
+        current->mark = TRUE;
+    }
+
+    return retval;
+}
+
+/* --------------------------------------------------------------------------------------------- */
+/** Delete subdirectories which still have the deletion mark */
+
+void
+tree_store_end_check (void)
+{
+    tree_entry *current;
+    size_t len;
+    GList *the_queue;
+
+    if (!ts.loaded)
+        return;
+
+    g_return_if_fail (ts.check_name != NULL);
+
+    /* Check delete marks and delete if found */
+    len = vfs_path_len (ts.check_name);
+
+    current = ts.check_start;
+    while (current != NULL && vfs_path_equal_len (current->name, ts.check_name, len))
+    {
+        gboolean ok;
+        tree_entry *old;
+        const char *cname;
+
+        cname = vfs_path_as_str (current->name);
+        ok = (cname[len] == '\0' || IS_PATH_SEP (cname[len]) || len == 1);
+        if (!ok)
+            break;
+
+        old = current;
+        current = current->next;
+        if (old->mark)
+            remove_entry (old);
+    }
+
+    /* get the stuff in the scan order */
+    the_queue = g_list_reverse (ts.add_queue_vpath);
+    ts.add_queue_vpath = NULL;
+    vfs_path_free (ts.check_name, TRUE);
+    ts.check_name = NULL;
+
+    g_list_free_full (the_queue, queue_vpath_free);
+}
+
+/* --------------------------------------------------------------------------------------------- */
+
+tree_entry *
+tree_store_rescan (const vfs_path_t * vpath)
+{
+    DIR *dirp;
+    struct stat buf;
+    tree_entry *entry;
+
+    if (should_skip_directory (vpath))
+    {
+        entry = tree_store_add_entry (vpath);
+        entry->scanned = TRUE;
+        return entry;
+    }
+
+    entry = tree_store_start_check (vpath);
+    if (entry == NULL)
+        return NULL;
+
+    dirp = mc_opendir (vpath);
+    if (dirp != NULL)
+    {
+        struct vfs_dirent *dp;
+
+        for (dp = mc_readdir (dirp); dp != NULL; dp = mc_readdir (dirp))
+            if (!DIR_IS_DOT (dp->d_name) && !DIR_IS_DOTDOT (dp->d_name))
+            {
+                vfs_path_t *tmp_vpath;
+
+                tmp_vpath = vfs_path_append_new (vpath, dp->d_name, (char *) NULL);
+                if (mc_lstat (tmp_vpath, &buf) != -1 && S_ISDIR (buf.st_mode))
+                    tree_store_mark_checked (dp->d_name);
+                vfs_path_free (tmp_vpath, TRUE);
+            }
+
+        mc_closedir (dirp);
+    }
+    tree_store_end_check ();
+    entry->scanned = TRUE;
+
+    return entry;
+}
+
+/* --------------------------------------------------------------------------------------------- */