src/filemanager/treestore.c

   1 /*
   2    Tree Store
   3    Contains a storage of the file system tree representation
   4
   5    This module has been converted to be a widget.
   6
   7    The program load and saves the tree each time the tree widget is
   8    created and destroyed.  This is required for the future vfs layer,
   9    it will be possible to have tree views over virtual file systems.
  10
  11    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2009,
  12    2011
  13    The Free Software Foundation, Inc.
  14
  15    Written by:
  16    Janne Kukonlehto, 1994, 1996
  17    Norbert Warmuth, 1997
  18    Miguel de Icaza, 1996, 1999
  19
  20    This file is part of the Midnight Commander.
  21
  22    The Midnight Commander is free software: you can redistribute it
  23    and/or modify it under the terms of the GNU General Public License as
  24    published by the Free Software Foundation, either version 3 of the License,
  25    or (at your option) any later version.
  26
  27    The Midnight Commander is distributed in the hope that it will be useful,
  28    but WITHOUT ANY WARRANTY; without even the implied warranty of
  29    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30    GNU General Public License for more details.
  31
  32    You should have received a copy of the GNU General Public License
  33    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  34  */
  35
  36 /** \file treestore.c
  37  *  \brief Source: tree store
  38  *
  39  *  Contains a storage of the file system tree representation.
  40  */
  41
  42 #include <config.h>
  43
  44 #include <errno.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <sys/types.h>
  49 #include <sys/stat.h>
  50 #include <unistd.h>
  51
  52 #include "lib/global.h"
  53 #include "lib/mcconfig.h"
  54 #include "lib/vfs/vfs.h"
  55 #include "lib/fileloc.h"
  56 #include "lib/hook.h"
  57 #include "lib/util.h"
  58
  59 #include "src/setup.h"
  60
  61 #include "treestore.h"
  62
  63 /*** global variables ****************************************************************************/
  64
  65 /*** file scope macro definitions ****************************************************************/
  66
  67 #define TREE_SIGNATURE "Midnight Commander TreeStore v 2.0"
  68
  69 /*** file scope type declarations ****************************************************************/
  70
  71 /*** file scope variables ************************************************************************/
  72
  73 static struct TreeStore ts;
  74
  75 static hook_t *remove_entry_hooks;
  76
  77 /*** file scope functions ************************************************************************/
  78 /* --------------------------------------------------------------------------------------------- */
  79
  80 static tree_entry *tree_store_add_entry (const char *name);
  81
  82 /* --------------------------------------------------------------------------------------------- */
  83
  84 static void
  85 tree_store_dirty (int state)
  86 {
  87     ts.dirty = state;
  88 }
  89
  90 /* --------------------------------------------------------------------------------------------- */
  91 /** Returns the number of common bytes in the strings. */
  92
  93 static size_t
  94 str_common (const char *s1, const char *s2)
  95 {
  96     size_t result = 0;
  97
  98     while (*s1 != '\0' && *s2 != '\0' && *s1++ == *s2++)
  99         result++;
 100     return result;
 101 }
 102
 103 /* --------------------------------------------------------------------------------------------- */
 104 /* The directory names are arranged in a single linked list in the same
 105    order as they are displayed. When the tree is displayed the expected
 106    order is like this:
 107    /
 108    /bin
 109    /etc
 110    /etc/X11
 111    /etc/rc.d
 112    /etc.old/X11
 113    /etc.old/rc.d
 114    /usr
 115
 116    i.e. the required collating sequence when comparing two directory names is
 117    '\0' < PATH_SEP < all-other-characters-in-encoding-order
 118
 119    Since strcmp doesn't fulfil this requirement we use pathcmp when
 120    inserting directory names into the list. The meaning of the return value
 121    of pathcmp and strcmp are the same (an integer less than, equal to, or
 122    greater than zero if p1 is found to be less than, to match, or be greater
 123    than p2.
 124  */
 125
 126 static int
 127 pathcmp (const char *p1, const char *p2)
 128 {
 129     for (; *p1 == *p2; p1++, p2++)
 130         if (*p1 == '\0')
 131             return 0;
 132
 133     if (*p1 == '\0')
 134         return -1;
 135     if (*p2 == '\0')
 136         return 1;
 137     if (*p1 == PATH_SEP)
 138         return -1;
 139     if (*p2 == PATH_SEP)
 140         return 1;
 141     return (*p1 - *p2);
 142 }
 143
 144 /* --------------------------------------------------------------------------------------------- */
 145
 146 static char *
 147 decode (char *buffer)
 148 {
 149     char *res = g_strdup (buffer);
 150     char *p, *q;
 151
 152     for (p = q = res; *p; p++, q++)
 153     {
 154         if (*p == '\n')
 155         {
 156             *q = 0;
 157             return res;
 158         }
 159
 160         if (*p != '\\')
 161         {
 162             *q = *p;
 163             continue;
 164         }
 165
 166         p++;
 167
 168         switch (*p)
 169         {
 170         case 'n':
 171             *q = '\n';
 172             break;
 173         case '\\':
 174             *q = '\\';
 175             break;
 176         }
 177     }
 178     *q = *p;
 179
 180     return res;
 181 }
 182
 183 /* --------------------------------------------------------------------------------------------- */
 184 /** Loads the tree store from the specified filename */
 185
 186 static int
 187 tree_store_load_from (char *name)
 188 {
 189     FILE *file;
 190     char buffer[MC_MAXPATHLEN + 20], oldname[MC_MAXPATHLEN];
 191     char *different;
 192     int common;
 193     int do_load;
 194
 195     g_return_val_if_fail (name != NULL, FALSE);
 196
 197     if (ts.loaded)
 198         return TRUE;
 199
 200     file = fopen (name, "r");
 201
 202     if (file)
 203     {
 204         if (fgets (buffer, sizeof (buffer), file) != NULL)
 205         {
 206             if (strncmp (buffer, TREE_SIGNATURE, strlen (TREE_SIGNATURE)) != 0)
 207             {
 208                 fclose (file);
 209                 do_load = FALSE;
 210             }
 211             else
 212                 do_load = TRUE;
 213         }
 214         else
 215             do_load = FALSE;
 216     }
 217     else
 218         do_load = FALSE;
 219
 220     if (do_load)
 221     {
 222         ts.loaded = TRUE;
 223
 224         /* File open -> read contents */
 225         oldname[0] = 0;
 226         while (fgets (buffer, MC_MAXPATHLEN, file))
 227         {
 228             tree_entry *e;
 229             int scanned;
 230             char *lc_name;
 231
 232             /* Skip invalid records */
 233             if ((buffer[0] != '0' && buffer[0] != '1'))
 234                 continue;
 235
 236             if (buffer[1] != ':')
 237                 continue;
 238
 239             scanned = buffer[0] == '1';
 240
 241             lc_name = decode (buffer + 2);
 242             if (lc_name[0] != PATH_SEP)
 243             {
 244                 /* Clear-text decompression */
 245                 char *s = strtok (lc_name, " ");
 246
 247                 if (s)
 248                 {
 249                     common = atoi (s);
 250                     different = strtok (NULL, "");
 251                     if (different)
 252                     {
 253                         vfs_path_t *vpath = vfs_path_from_str (oldname);
 254                         strcpy (oldname + common, different);
 255                         if (vfs_file_is_local (vpath))
 256                         {
 257                             e = tree_store_add_entry (oldname);
 258                             e->scanned = scanned;
 259                         }
 260                         vfs_path_free (vpath);
 261                     }
 262                 }
 263             }
 264             else
 265             {
 266                 vfs_path_t *vpath = vfs_path_from_str (lc_name);
 267                 if (vfs_file_is_local (vpath))
 268                 {
 269                     e = tree_store_add_entry (lc_name);
 270                     e->scanned = scanned;
 271                 }
 272                 vfs_path_free (vpath);
 273                 strcpy (oldname, lc_name);
 274             }
 275             g_free (lc_name);
 276         }
 277         fclose (file);
 278     }
 279
 280     /* Nothing loaded, we add some standard directories */
 281     if (!ts.tree_first)
 282     {
 283         vfs_path_t *tmp_vpath = vfs_path_from_str (PATH_SEP_STR);
 284         tree_store_add_entry (PATH_SEP_STR);
 285         tree_store_rescan (tmp_vpath);
 286         vfs_path_free (tmp_vpath);
 287         ts.loaded = TRUE;
 288     }
 289
 290     return TRUE;
 291 }
 292
 293 /* --------------------------------------------------------------------------------------------- */
 294
 295 static char *
 296 encode (const char *string)
 297 {
 298     int special_chars;
 299     const char *p;
 300     char *q;
 301     char *res;
 302
 303     for (special_chars = 0, p = string; *p; p++)
 304     {
 305         if (*p == '\n' || *p == '\\')
 306             special_chars++;
 307     }
 308
 309     res = g_malloc (p - string + special_chars + 1);
 310     for (p = string, q = res; *p; p++, q++)
 311     {
 312         if (*p != '\n' && *p != '\\')
 313         {
 314             *q = *p;
 315             continue;
 316         }
 317
 318         *q++ = '\\';
 319
 320         switch (*p)
 321         {
 322         case '\n':
 323             *q = 'n';
 324             break;
 325
 326         case '\\':
 327             *q = '\\';
 328             break;
 329         }
 330     }
 331     *q = 0;
 332     return res;
 333 }
 334
 335 /* --------------------------------------------------------------------------------------------- */
 336 /** Saves the tree to the specified filename */
 337
 338 static int
 339 tree_store_save_to (char *name)
 340 {
 341     tree_entry *current;
 342     FILE *file;
 343
 344     file = fopen (name, "w");
 345     if (!file)
 346         return errno;
 347
 348     fprintf (file, "%s\n", TREE_SIGNATURE);
 349
 350     current = ts.tree_first;
 351     while (current)
 352     {
 353         int i, common;
 354         vfs_path_t *vpath = vfs_path_from_str (current->name);
 355
 356         if (vfs_file_is_local (vpath))
 357         {
 358             /* Clear-text compression */
 359             if (current->prev && (common = str_common (current->prev->name, current->name)) > 2)
 360             {
 361                 char *encoded = encode (current->name + common);
 362
 363                 i = fprintf (file, "%d:%d %s\n", current->scanned, common, encoded);
 364                 g_free (encoded);
 365             }
 366             else
 367             {
 368                 char *encoded = encode (current->name);
 369
 370                 i = fprintf (file, "%d:%s\n", current->scanned, encoded);
 371                 g_free (encoded);
 372             }
 373
 374             if (i == EOF)
 375             {
 376                 fprintf (stderr, _("Cannot write to the %s file:\n%s\n"),
 377                          name, unix_error_string (errno));
 378                 vfs_path_free (vpath);
 379                 break;
 380             }
 381         }
 382         vfs_path_free (vpath);
 383         current = current->next;
 384     }
 385     tree_store_dirty (FALSE);
 386     fclose (file);
 387
 388     return 0;
 389 }
 390
 391 /* --------------------------------------------------------------------------------------------- */
 392
 393 static tree_entry *
 394 tree_store_add_entry (const char *name)
 395 {
 396     int flag = -1;
 397     tree_entry *current = ts.tree_first;
 398     tree_entry *old = NULL;
 399     tree_entry *new;
 400     int i, len;
 401     int submask = 0;
 402
 403     if (ts.tree_last && ts.tree_last->next)
 404         abort ();
 405
 406     /* Search for the correct place */
 407     while (current && (flag = pathcmp (current->name, name)) < 0)
 408     {
 409         old = current;
 410         current = current->next;
 411     }
 412
 413     if (flag == 0)
 414         return current;         /* Already in the list */
 415
 416     /* Not in the list -> add it */
 417     new = g_new0 (tree_entry, 1);
 418     if (!current)
 419     {
 420         /* Append to the end of the list */
 421         if (!ts.tree_first)
 422         {
 423             /* Empty list */
 424             ts.tree_first = new;
 425             new->prev = NULL;
 426         }
 427         else
 428         {
 429             old->next = new;
 430             new->prev = old;
 431         }
 432         new->next = NULL;
 433         ts.tree_last = new;
 434     }
 435     else
 436     {
 437         /* Insert in to the middle of the list */
 438         new->prev = old;
 439         if (old)
 440         {
 441             /* Yes, in the middle */
 442             new->next = old->next;
 443             old->next = new;
 444         }
 445         else
 446         {
 447             /* Nope, in the beginning of the list */
 448             new->next = ts.tree_first;
 449             ts.tree_first = new;
 450         }
 451         new->next->prev = new;
 452     }
 453
 454     /* Calculate attributes */
 455     new->name = g_strdup (name);
 456     len = strlen (new->name);
 457     new->sublevel = 0;
 458     for (i = 0; i < len; i++)
 459         if (new->name[i] == PATH_SEP)
 460         {
 461             new->sublevel++;
 462             new->subname = new->name + i + 1;
 463         }
 464     if (new->next)
 465         submask = new->next->submask;
 466     else
 467         submask = 0;
 468     submask |= 1 << new->sublevel;
 469     submask &= (2 << new->sublevel) - 1;
 470     new->submask = submask;
 471     new->mark = 0;
 472
 473     /* Correct the submasks of the previous entries */
 474     current = new->prev;
 475     while (current && current->sublevel > new->sublevel)
 476     {
 477         current->submask |= 1 << new->sublevel;
 478         current = current->prev;
 479     }
 480
 481     /* The entry has now been added */
 482
 483     if (new->sublevel > 1)
 484     {
 485         /* Let's check if the parent directory is in the tree */
 486         char *parent = g_strdup (new->name);
 487
 488         for (i = strlen (parent) - 1; i > 1; i--)
 489         {
 490             if (parent[i] == PATH_SEP)
 491             {
 492                 parent[i] = 0;
 493                 tree_store_add_entry (parent);
 494                 break;
 495             }
 496         }
 497         g_free (parent);
 498     }
 499
 500     tree_store_dirty (TRUE);
 501     return new;
 502 }
 503
 504 /* --------------------------------------------------------------------------------------------- */
 505
 506 static void
 507 tree_store_notify_remove (tree_entry * entry)
 508 {
 509     hook_t *p = remove_entry_hooks;
 510     tree_store_remove_fn r;
 511
 512     while (p != NULL)
 513     {
 514         r = (tree_store_remove_fn) p->hook_fn;
 515         r (entry, p->hook_data);
 516         p = p->next;
 517     }
 518 }
 519
 520 /* --------------------------------------------------------------------------------------------- */
 521
 522 static tree_entry *
 523 remove_entry (tree_entry * entry)
 524 {
 525     tree_entry *current = entry->prev;
 526     long submask = 0;
 527     tree_entry *ret = NULL;
 528
 529     tree_store_notify_remove (entry);
 530
 531     /* Correct the submasks of the previous entries */
 532     if (entry->next)
 533         submask = entry->next->submask;
 534     while (current && current->sublevel > entry->sublevel)
 535     {
 536         submask |= 1 << current->sublevel;
 537         submask &= (2 << current->sublevel) - 1;
 538         current->submask = submask;
 539         current = current->prev;
 540     }
 541
 542     /* Unlink the entry from the list */
 543     if (entry->prev)
 544         entry->prev->next = entry->next;
 545     else
 546         ts.tree_first = entry->next;
 547
 548     if (entry->next)
 549         entry->next->prev = entry->prev;
 550     else
 551         ts.tree_last = entry->prev;
 552
 553     /* Free the memory used by the entry */
 554     g_free (entry->name);
 555     g_free (entry);
 556
 557     return ret;
 558 }
 559
 560 /* --------------------------------------------------------------------------------------------- */
 561
 562 static void
 563 process_special_dirs (GList ** special_dirs, char *file)
 564 {
 565     gchar **buffers, **start_buff;
 566     mc_config_t *cfg;
 567     gsize buffers_len;
 568
 569     cfg = mc_config_init (file);
 570     if (cfg == NULL)
 571         return;
 572
 573     start_buff = buffers = mc_config_get_string_list (cfg, "Special dirs", "list", &buffers_len);
 574     if (buffers != NULL)
 575     {
 576         while (*buffers != NULL)
 577         {
 578             *special_dirs = g_list_prepend (*special_dirs, *buffers);
 579             *buffers = NULL;
 580             buffers++;
 581         }
 582         g_strfreev (start_buff);
 583     }
 584     mc_config_deinit (cfg);
 585 }
 586
 587 /* --------------------------------------------------------------------------------------------- */
 588
 589 static gboolean
 590 should_skip_directory (const char *dir)
 591 {
 592     static GList *special_dirs = NULL;
 593     GList *l;
 594     static gboolean loaded = FALSE;
 595
 596     if (!loaded)
 597     {
 598         loaded = TRUE;
 599         setup_init ();
 600         process_special_dirs (&special_dirs, profile_name);
 601         process_special_dirs (&special_dirs, global_profile_name);
 602     }
 603
 604     for (l = special_dirs; l != NULL; l = g_list_next (l))
 605         if (strncmp (dir, l->data, strlen (l->data)) == 0)
 606             return TRUE;
 607
 608     return FALSE;
 609 }
 610
 611 /* --------------------------------------------------------------------------------------------- */
 612 /*** public functions ****************************************************************************/
 613 /* --------------------------------------------------------------------------------------------- */
 614
 615 /* Searches for specified directory */
 616 tree_entry *
 617 tree_store_whereis (const char *name)
 618 {
 619     tree_entry *current = ts.tree_first;
 620     int flag = -1;
 621
 622     while (current && (flag = pathcmp (current->name, name)) < 0)
 623         current = current->next;
 624
 625     if (flag == 0)
 626         return current;
 627     else
 628         return NULL;
 629 }
 630
 631 /* --------------------------------------------------------------------------------------------- */
 632
 633 struct TreeStore *
 634 tree_store_get (void)
 635 {
 636     return &ts;
 637 }
 638
 639 /* --------------------------------------------------------------------------------------------- */
 640 /**
 641  * \fn int tree_store_load(void)
 642  * \brief Loads the tree from the default location
 643  * \return 1 if success (true), 0 otherwise (false)
 644  */
 645
 646 int
 647 tree_store_load (void)
 648 {
 649     char *name;
 650     int retval;
 651
 652     name = mc_config_get_full_path (MC_TREESTORE_FILE);
 653     retval = tree_store_load_from (name);
 654     g_free (name);
 655
 656     return retval;
 657 }
 658
 659 /* --------------------------------------------------------------------------------------------- */
 660 /**
 661  * \fn int tree_store_save(void)
 662  * \brief Saves the tree to the default file in an atomic fashion
 663  * \return 0 if success, errno on error
 664  */
 665
 666 int
 667 tree_store_save (void)
 668 {
 669     char *name;
 670     int retval;
 671
 672     name = mc_config_get_full_path (MC_TREESTORE_FILE);
 673     mc_util_make_backup_if_possible (name, ".tmp");
 674
 675     retval = tree_store_save_to (name);
 676     if (retval != 0)
 677     {
 678         mc_util_restore_from_backup_if_possible (name, ".tmp");
 679         g_free (name);
 680         return retval;
 681     }
 682
 683     mc_util_unlink_backup_if_possible (name, ".tmp");
 684     g_free (name);
 685     return 0;
 686 }
 687
 688 /* --------------------------------------------------------------------------------------------- */
 689
 690 void
 691 tree_store_add_entry_remove_hook (tree_store_remove_fn callback, void *data)
 692 {
 693     add_hook (&remove_entry_hooks, (void (*)(void *)) callback, data);
 694 }
 695
 696 /* --------------------------------------------------------------------------------------------- */
 697
 698 void
 699 tree_store_remove_entry_remove_hook (tree_store_remove_fn callback)
 700 {
 701     delete_hook (&remove_entry_hooks, (void (*)(void *)) callback);
 702 }
 703
 704
 705 /* --------------------------------------------------------------------------------------------- */
 706
 707 void
 708 tree_store_remove_entry (const char *name)
 709 {
 710     tree_entry *current, *base, *old;
 711     int len;
 712
 713     g_return_if_fail (name != NULL);
 714
 715     /* Miguel Ugly hack */
 716     if (name[0] == PATH_SEP && name[1] == 0)
 717         return;
 718     /* Miguel Ugly hack end */
 719
 720     base = tree_store_whereis (name);
 721     if (!base)
 722         return;                 /* Doesn't exist */
 723
 724     len = strlen (base->name);
 725     current = base->next;
 726     while (current
 727            && strncmp (current->name, base->name, len) == 0
 728            && (current->name[len] == '\0' || current->name[len] == PATH_SEP))
 729     {
 730         old = current;
 731         current = current->next;
 732         remove_entry (old);
 733     }
 734     remove_entry (base);
 735     tree_store_dirty (TRUE);
 736
 737     return;
 738 }
 739
 740 /* --------------------------------------------------------------------------------------------- */
 741 /** This subdirectory exists -> clear deletion mark */
 742
 743 void
 744 tree_store_mark_checked (const char *subname)
 745 {
 746     char *name;
 747     tree_entry *current, *base;
 748     int flag = 1, len;
 749     if (!ts.loaded)
 750         return;
 751
 752     if (ts.check_name == NULL)
 753         return;
 754
 755     /* Calculate the full name of the subdirectory */
 756     if (subname[0] == '.' && (subname[1] == 0 || (subname[1] == '.' && subname[2] == 0)))
 757         return;
 758     if (ts.check_name[0] == PATH_SEP && ts.check_name[1] == 0)
 759         name = g_strconcat (PATH_SEP_STR, subname, (char *) NULL);
 760     else
 761         name = concat_dir_and_file (ts.check_name, subname);
 762
 763     /* Search for the subdirectory */
 764     current = ts.check_start;
 765     while (current && (flag = pathcmp (current->name, name)) < 0)
 766         current = current->next;
 767
 768     if (flag != 0)
 769     {
 770         /* Doesn't exist -> add it */
 771         current = tree_store_add_entry (name);
 772         ts.add_queue = g_list_prepend (ts.add_queue, g_strdup (name));
 773     }
 774     g_free (name);
 775
 776     /* Clear the deletion mark from the subdirectory and its children */
 777     base = current;
 778     if (base)
 779     {
 780         len = strlen (base->name);
 781         base->mark = 0;
 782         current = base->next;
 783         while (current
 784                && strncmp (current->name, base->name, len) == 0
 785                && (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1))
 786         {
 787             current->mark = 0;
 788             current = current->next;
 789         }
 790     }
 791 }
 792
 793 /* --------------------------------------------------------------------------------------------- */
 794 /** Mark the subdirectories of the current directory for delete */
 795
 796 tree_entry *
 797 tree_store_start_check (const char *path)
 798 {
 799     tree_entry *current, *retval;
 800     size_t len;
 801
 802     if (!ts.loaded)
 803         return NULL;
 804
 805     g_return_val_if_fail (ts.check_name == NULL, NULL);
 806     ts.check_start = NULL;
 807
 808     /* Search for the start of subdirectories */
 809     current = tree_store_whereis (path);
 810     if (!current)
 811     {
 812         struct stat s;
 813         vfs_path_t *vpath = vfs_path_from_str (path);
 814
 815         if (mc_stat (vpath, &s) == -1)
 816         {
 817             vfs_path_free (vpath);
 818             return NULL;
 819         }
 820         vfs_path_free (vpath);
 821
 822         if (!S_ISDIR (s.st_mode))
 823             return NULL;
 824
 825         current = tree_store_add_entry (path);
 826         ts.check_name = g_strdup (path);
 827
 828         return current;
 829     }
 830
 831     ts.check_name = g_strdup (path);
 832
 833     retval = current;
 834
 835     /* Mark old subdirectories for delete */
 836     ts.check_start = current->next;
 837     len = strlen (ts.check_name);
 838
 839     current = ts.check_start;
 840     while (current
 841            && strncmp (current->name, ts.check_name, len) == 0
 842            && (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1))
 843     {
 844         current->mark = 1;
 845         current = current->next;
 846     }
 847
 848     return retval;
 849 }
 850
 851 /* --------------------------------------------------------------------------------------------- */
 852 /** Delete subdirectories which still have the deletion mark */
 853
 854 void
 855 tree_store_end_check (void)
 856 {
 857     tree_entry *current, *old;
 858     size_t len;
 859     GList *the_queue;
 860
 861     if (!ts.loaded)
 862         return;
 863
 864     g_return_if_fail (ts.check_name != NULL);
 865
 866     /* Check delete marks and delete if found */
 867     len = strlen (ts.check_name);
 868
 869     current = ts.check_start;
 870     while (current
 871            && strncmp (current->name, ts.check_name, len) == 0
 872            && (current->name[len] == '\0' || current->name[len] == PATH_SEP || len == 1))
 873     {
 874         old = current;
 875         current = current->next;
 876         if (old->mark)
 877             remove_entry (old);
 878     }
 879
 880     /* get the stuff in the scan order */
 881     ts.add_queue = g_list_reverse (ts.add_queue);
 882     the_queue = ts.add_queue;
 883     ts.add_queue = NULL;
 884     g_free (ts.check_name);
 885     ts.check_name = NULL;
 886
 887     g_list_foreach (the_queue, (GFunc) g_free, NULL);
 888     g_list_free (the_queue);
 889 }
 890
 891 /* --------------------------------------------------------------------------------------------- */
 892
 893 tree_entry *
 894 tree_store_rescan (const vfs_path_t * vpath)
 895 {
 896     DIR *dirp;
 897     struct dirent *dp;
 898     struct stat buf;
 899     tree_entry *entry;
 900     char *dir = vfs_path_to_str (vpath);
 901
 902     if (should_skip_directory (dir))
 903     {
 904         entry = tree_store_add_entry (dir);
 905         entry->scanned = 1;
 906         g_free (dir);
 907         return entry;
 908     }
 909
 910     entry = tree_store_start_check (dir);
 911
 912     if (!entry)
 913     {
 914         g_free (dir);
 915         return NULL;
 916     }
 917
 918     dirp = mc_opendir (vpath);
 919     if (dirp)
 920     {
 921         for (dp = mc_readdir (dirp); dp; dp = mc_readdir (dirp))
 922         {
 923             vfs_path_t *tmp_vpath;
 924
 925             if (dp->d_name[0] == '.')
 926             {
 927                 if (dp->d_name[1] == 0 || (dp->d_name[1] == '.' && dp->d_name[2] == 0))
 928                     continue;
 929             }
 930
 931             tmp_vpath = vfs_path_append_new (vpath, dp->d_name, NULL);
 932             if (mc_lstat (tmp_vpath, &buf) != -1)
 933             {
 934                 if (S_ISDIR (buf.st_mode))
 935                     tree_store_mark_checked (dp->d_name);
 936             }
 937             vfs_path_free (tmp_vpath);
 938         }
 939         mc_closedir (dirp);
 940     }
 941     tree_store_end_check ();
 942     entry->scanned = 1;
 943     g_free (dir);
 944
 945     return entry;
 946 }
 947
 948 /* --------------------------------------------------------------------------------------------- */