src/treestore.c

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