src/treestore.c

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