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