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