ROX-Filer/src/dir.c

   1 /*
   2  * $Id$
   3  *
   4  * dir.c - Caches and updates directories
   5  * Copyright (C) 2000, Thomas Leonard, <tal197@users.sourceforge.net>.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <gtk/gtk.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include "global.h"
  30
  31 #include "support.h"
  32 #include "gui_support.h"
  33 #include "dir.h"
  34 #include "fscache.h"
  35 #include "mount.h"
  36 #include "pixmaps.h"
  37 #include "type.h"
  38
  39 GFSCache *dir_cache = NULL;
  40
  41 /* Static prototypes */
  42 static Directory *load(char *pathname, gpointer data);
  43 static void ref(Directory *dir, gpointer data);
  44 static void unref(Directory *dir, gpointer data);
  45 static int getref(Directory *dir, gpointer data);
  46 static void update(Directory *dir, gchar *pathname, gpointer data);
  47 static void destroy(Directory *dir);
  48 static void start_scanning(Directory *dir, char *pathname);
  49 static gint idle_callback(Directory *dir);
  50 static void init_for_scan(Directory *dir);
  51 static void merge_new(Directory *dir);
  52
  53
  54 /****************************************************************
  55  *                      EXTERNAL INTERFACE                      *
  56  ****************************************************************/
  57
  58 void dir_init(void)
  59 {
  60         dir_cache = g_fscache_new((GFSLoadFunc) load,
  61                                 (GFSRefFunc) ref,
  62                                 (GFSRefFunc) unref,
  63                                 (GFSGetRefFunc) getref,
  64                                 (GFSUpdateFunc) update, NULL);
  65 }
  66
  67 /* Periodically calls callback to notify about changes to the contents
  68  * of the directory.
  69  * Before this function returns, it calls the callback once to add all
  70  * the items currently in the directory (unless the dir is empty).
  71  * If we are not scanning, it also calls update(DIR_END_SCAN).
  72  */
  73 void dir_attach(Directory *dir, DirCallback callback, gpointer data)
  74 {
  75         DirUser *user;
  76
  77         g_return_if_fail(dir != NULL);
  78         g_return_if_fail(callback != NULL);
  79
  80         user = g_new(DirUser, 1);
  81         user->callback = callback;
  82         user->data = data;
  83
  84         dir->users = g_list_prepend(dir->users, user);
  85
  86         ref(dir, NULL);
  87
  88         if (dir->items->len)
  89                 callback(dir, DIR_ADD, dir->items, data);
  90
  91         if (dir->needs_update)
  92                 start_scanning(dir, dir->pathname);
  93
  94         if (dir->error)
  95                 delayed_error(PROJECT, dir->error);
  96
  97         if (!dir->dir_handle)
  98                 callback(dir, DIR_END_SCAN, NULL, data);
  99 }
 100
 101 /* Undo the effect of dir_attach */
 102 void dir_detach(Directory *dir, DirCallback callback, gpointer data)
 103 {
 104         DirUser *user;
 105         GList   *list = dir->users;
 106
 107         g_return_if_fail(dir != NULL);
 108         g_return_if_fail(callback != NULL);
 109
 110         while (list)
 111         {
 112                 user = (DirUser *) list->data;
 113                 if (user->callback == callback && user->data == data)
 114                 {
 115                         g_free(user);
 116                         dir->users = g_list_remove(dir->users, user);
 117                         unref(dir, NULL);
 118                         if (!dir->users)
 119                         {
 120                                 if (dir->dir_handle)
 121                                 {
 122                                         mc_closedir(dir->dir_handle);
 123                                         dir->dir_handle = NULL;
 124                                         gtk_idle_remove(dir->idle);
 125                                         merge_new(dir);
 126                                         dir->needs_update = TRUE;
 127                                 }
 128                         }
 129                         return;
 130                 }
 131                 list = list->next;
 132         }
 133
 134         g_warning("dir_detach: Callback/data pair not attached!\n");
 135 }
 136
 137 void dir_update(Directory *dir, gchar *pathname)
 138 {
 139         update(dir, pathname, NULL);
 140 }
 141
 142 int dir_item_cmp(const void *a, const void *b)
 143 {
 144         DirItem *aa = *((DirItem **) a);
 145         DirItem *bb = *((DirItem **) b);
 146
 147         return strcmp(aa->leafname, bb->leafname);
 148 }
 149
 150 void refresh_dirs(char *path)
 151 {
 152         g_fscache_update(dir_cache, path);
 153 }
 154
 155 /* Bring this item's structure uptodate */
 156 void dir_restat(guchar *path, DirItem *item)
 157 {
 158         struct stat     info;
 159
 160         if (item->image && item->flags & ITEM_FLAG_TEMP_ICON)
 161         {
 162                 pixmap_unref(item->image);
 163                 item->image = NULL;
 164         }
 165         item->flags = 0;
 166         item->mime_type = NULL;
 167
 168         if (mc_lstat(path, &info) == -1)
 169         {
 170                 item->lstat_errno = errno;
 171                 item->base_type = TYPE_ERROR;
 172                 item->size = 0;
 173                 item->mode = 0;
 174                 item->mtime = 0;
 175                 item->uid = (uid_t) -1;
 176                 item->gid = (gid_t) -1;
 177         }
 178         else
 179         {
 180                 item->lstat_errno = 0;
 181                 item->size = info.st_size;
 182                 item->mode = info.st_mode;
 183                 item->mtime = info.st_mtime;
 184                 item->uid = info.st_uid;
 185                 item->gid = info.st_gid;
 186
 187                 if (S_ISLNK(info.st_mode))
 188                 {
 189                         if (mc_stat(path, &info))
 190                                 item->base_type = TYPE_ERROR;
 191                         else
 192                                 item->base_type =
 193                                         mode_to_base_type(info.st_mode);
 194
 195                         item->flags |= ITEM_FLAG_SYMLINK;
 196                 }
 197                 else
 198                 {
 199                         item->base_type = mode_to_base_type(info.st_mode);
 200
 201                         if (item->base_type == TYPE_DIRECTORY)
 202                         {
 203                                 if (g_hash_table_lookup(mtab_mounts, path))
 204                                         item->flags |= ITEM_FLAG_MOUNT_POINT
 205                                                         | ITEM_FLAG_MOUNTED;
 206                                 else if (g_hash_table_lookup(fstab_mounts,
 207                                                                 path))
 208                                         item->flags |= ITEM_FLAG_MOUNT_POINT;
 209                         }
 210                 }
 211         }
 212
 213         if (item->base_type == TYPE_DIRECTORY &&
 214                         !(item->flags & ITEM_FLAG_MOUNT_POINT))
 215         {
 216                 uid_t   uid = info.st_uid;
 217                 int     path_len;
 218                 guchar  *tmp;
 219
 220                 /* Might be an application directory - better check...
 221                  * AppRun must have the same owner as the directory
 222                  * (to stop people putting an AppRun in, eg, /tmp)
 223                  */
 224                 path_len = strlen(path);
 225                 /* (sizeof(string) includes \0) */
 226                 tmp = g_malloc(path_len + sizeof("/AppIcon.xpm"));
 227                 sprintf(tmp, "%s/%s", path, "AppRun");
 228                 if (!mc_stat(tmp, &info) && info.st_uid == uid)
 229                 {
 230                         MaskedPixmap *app_icon;
 231
 232                         item->flags |= ITEM_FLAG_APPDIR;
 233
 234                         strcpy(tmp + path_len + 4, "Icon.xpm");
 235                         app_icon = g_fscache_lookup(pixmap_cache, tmp);
 236                         if (app_icon)
 237                         {
 238                                 item->image = app_icon;
 239                                 item->flags |= ITEM_FLAG_TEMP_ICON;
 240                         }
 241                         else
 242                                 item->image = im_appdir;
 243                 }
 244                 g_free(tmp);
 245         }
 246         else if (item->base_type == TYPE_FILE)
 247         {
 248                 /* Note: for symlinks we use need the mode of the target */
 249                 if (info.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
 250                 {
 251                         item->image = im_exec_file;
 252                         item->flags |= ITEM_FLAG_EXEC_FILE;
 253                 }
 254                 else
 255                 {
 256                         item->mime_type = type_from_path(path);
 257                         item->flags |= ITEM_FLAG_TEMP_ICON;
 258                 }
 259         }
 260
 261         if (!item->mime_type)
 262                 item->mime_type = mime_type_from_base_type(item->base_type);
 263
 264         if (!item->image)
 265                 item->image = type_to_icon(item->mime_type);
 266 }
 267
 268 /* Fill in the item structure with the appropriate details.
 269  * 'leafname' field is set to NULL; text_width is unset.
 270  */
 271 void dir_stat(guchar *path, DirItem *item)
 272 {
 273         item->leafname = NULL;
 274         item->may_delete = FALSE;
 275         item->image = NULL;
 276
 277         dir_restat(path, item);
 278 }
 279
 280 /* Frees all fields in the icon, but does not free the icon structure
 281  * itself (because it might be part of a larger structure).
 282  */
 283 void dir_item_clear(DirItem *item)
 284 {
 285         g_return_if_fail(item != NULL);
 286
 287         if (item->flags & ITEM_FLAG_TEMP_ICON)
 288                 pixmap_unref(item->image);
 289         g_free(item->leafname);
 290 }
 291
 292 /* When something has happened to a particular object, call this
 293  * and all appropriate changes will be made.
 294  * Currently, we just extract the dirname and rescan...
 295  */
 296 void dir_check_this(guchar *path)
 297 {
 298         guchar  *slash;
 299         guchar  *real_path;
 300
 301         real_path = pathdup(path);
 302
 303         slash = strrchr(real_path, '/');
 304
 305         if (slash)
 306         {
 307                 *slash = '\0';
 308                 refresh_dirs(real_path);
 309         }
 310
 311         g_free(real_path);
 312 }
 313
 314 /****************************************************************
 315  *                      INTERNAL FUNCTIONS                      *
 316  ****************************************************************/
 317
 318 static void free_items_array(GPtrArray *array)
 319 {
 320         int     i;
 321
 322         for (i = 0; i < array->len; i++)
 323         {
 324                 DirItem *item = (DirItem *) array->pdata[i];
 325
 326                 dir_item_clear(item);
 327                 g_free(item);
 328         }
 329
 330         g_ptr_array_free(array, TRUE);
 331 }
 332
 333 /* Scanning has finished. Remove all the old items that have gone.
 334  * Notify everyone who is watching us of the removed items and tell
 335  * them that the scan is over, unless 'needs_update'.
 336  */
 337 static void sweep_deleted(Directory *dir)
 338 {
 339         GPtrArray       *array = dir->items;
 340         int             items = array->len;
 341         int             new_items = 0;
 342         GPtrArray       *old;
 343         DirItem **from = (DirItem **) array->pdata;
 344         DirItem **to = (DirItem **) array->pdata;
 345         GList *list = dir->users;
 346
 347         old = g_ptr_array_new();
 348
 349         while (items--)
 350         {
 351                 if (from[0]->may_delete)
 352                 {
 353                         g_ptr_array_add(old, *from);
 354                         from++;
 355                         continue;
 356                 }
 357
 358                 if (from > to)
 359                         *to = *from;
 360                 to++;
 361                 from++;
 362                 new_items++;
 363         }
 364
 365         g_ptr_array_set_size(array, new_items);
 366
 367         while (list)
 368         {
 369                 DirUser *user = (DirUser *) list->data;
 370
 371                 if (old->len)
 372                         user->callback(dir, DIR_REMOVE, old, user->data);
 373                 if (!dir->needs_update)
 374                         user->callback(dir, DIR_END_SCAN, NULL, user->data);
 375
 376                 list = list->next;
 377         }
 378
 379         free_items_array(old);
 380 }
 381
 382
 383 /* Add all the new items to the items array.
 384  * Notify everyone who is watching us.
 385  */
 386 static void merge_new(Directory *dir)
 387 {
 388         GList *list = dir->users;
 389         GPtrArray       *new = dir->new_items;
 390         GPtrArray       *up = dir->up_items;
 391         int     i;
 392
 393         while (list)
 394         {
 395                 DirUser *user = (DirUser *) list->data;
 396
 397                 if (new->len)
 398                         user->callback(dir, DIR_ADD, new, user->data);
 399                 if (up->len)
 400                         user->callback(dir, DIR_UPDATE, up, user->data);
 401
 402                 list = list->next;
 403         }
 404
 405
 406         for (i = 0; i < new->len; i++)
 407                 g_ptr_array_add(dir->items, new->pdata[i]);
 408         qsort(dir->items->pdata, dir->items->len, sizeof(DirItem *),
 409                         dir_item_cmp);
 410
 411         g_ptr_array_set_size(new, 0);
 412         g_ptr_array_set_size(up, 0);
 413 }
 414
 415 static void init_for_scan(Directory *dir)
 416 {
 417         int     i;
 418
 419         dir->needs_update = FALSE;
 420         dir->done_some_scanning = FALSE;
 421
 422         for (i = 0; i < dir->items->len; i++)
 423                 ((DirItem *) dir->items->pdata[i])->may_delete = TRUE;
 424 }
 425
 426 static void start_scanning(Directory *dir, char *pathname)
 427 {
 428         GList   *next;
 429
 430         if (dir->dir_handle)
 431         {
 432                 /* We are already scanning */
 433                 if (dir->done_some_scanning)
 434                         dir->needs_update = TRUE;
 435                 return;
 436         }
 437
 438         mount_update(FALSE);
 439
 440         if (dir->error)
 441         {
 442                 g_free(dir->error);
 443                 dir->error = NULL;
 444         }
 445
 446         dir->dir_handle = mc_opendir(pathname);
 447
 448         if (!dir->dir_handle)
 449         {
 450                 dir->error = g_strdup_printf(_("Can't open directory: %s"),
 451                                 g_strerror(errno));
 452                 return;         /* Report on attach */
 453         }
 454
 455         dir->dir_start = mc_telldir(dir->dir_handle);
 456
 457         init_for_scan(dir);
 458
 459         dir->idle = gtk_idle_add((GtkFunction) idle_callback, dir);
 460
 461         /* Let all the filer windows know we're scanning */
 462         for (next = dir->users; next; next = next->next)
 463         {
 464                 DirUser *user = (DirUser *) next->data;
 465
 466                 user->callback(dir, DIR_START_SCAN, NULL, user->data);
 467         }
 468 }
 469
 470 static gint notify_timeout(gpointer data)
 471 {
 472         Directory       *dir = (Directory *) data;
 473
 474         g_return_val_if_fail(dir->notify_active == TRUE, FALSE);
 475
 476         merge_new(dir);
 477
 478         dir->notify_active = FALSE;
 479         unref(dir, NULL);
 480
 481         return FALSE;
 482 }
 483
 484 /* Call merge_new() after a while. */
 485 static void delayed_notify(Directory *dir)
 486 {
 487         if (dir->notify_active)
 488                 return;
 489         ref(dir, NULL);
 490         gtk_timeout_add(500, notify_timeout, dir);
 491         dir->notify_active = TRUE;
 492 }
 493
 494 static void insert_item(Directory *dir, struct dirent *ent)
 495 {
 496         static GString  *tmp = NULL;
 497
 498         GdkFont         *font;
 499         GPtrArray       *array = dir->items;
 500         DirItem         *item;
 501         int             i;
 502         DirItem         new;
 503         gboolean        is_new = FALSE;
 504
 505         tmp = make_path(dir->pathname, ent->d_name);
 506         dir_stat(tmp->str, &new);
 507
 508         /* Is an item with this name already listed? */
 509         for (i = 0; i < array->len; i++)
 510         {
 511                 item = (DirItem *) array->pdata[i];
 512
 513                 if (strcmp(item->leafname, ent->d_name) == 0)
 514                         goto update;
 515         }
 516
 517         item = g_new(DirItem, 1);
 518         item->leafname = g_strdup(ent->d_name);
 519         g_ptr_array_add(dir->new_items, item);
 520         delayed_notify(dir);
 521         is_new = TRUE;
 522 update:
 523         item->may_delete = FALSE;
 524
 525         font = gtk_widget_get_default_style()->font;
 526         new.name_width = gdk_string_width(font, item->leafname);
 527         new.leafname = item->leafname;
 528
 529         if (is_new == FALSE)
 530         {
 531                 if (item->flags & ITEM_FLAG_TEMP_ICON)
 532                         pixmap_unref(item->image);
 533                 if (item->lstat_errno == new.lstat_errno
 534                  && item->base_type == new.base_type
 535                  && item->flags == new.flags
 536                  && item->size == new.size
 537                  && item->mode == new.mode
 538                  && item->mtime == new.mtime
 539                  && item->uid == new.uid
 540                  && item->gid == new.gid
 541                  && item->image == new.image
 542                  && item->mime_type == new.mime_type
 543                  && item->name_width == new.name_width)
 544                         return;
 545         }
 546
 547         item->image = new.image;
 548         item->lstat_errno = new.lstat_errno;
 549         item->base_type = new.base_type;
 550         item->flags = new.flags;
 551         item->size = new.size;
 552         item->mode = new.mode;
 553         item->uid = new.uid;
 554         item->gid = new.gid;
 555         item->mtime = new.mtime;
 556         item->mime_type = new.mime_type;
 557         item->name_width = new.name_width;
 558
 559         if (!is_new)
 560         {
 561                 g_ptr_array_add(dir->up_items, item);
 562                 delayed_notify(dir);
 563         }
 564 }
 565
 566 static gint idle_callback(Directory *dir)
 567 {
 568         struct dirent *ent;
 569
 570         dir->done_some_scanning = TRUE;
 571
 572         do
 573         {
 574                 ent = mc_readdir(dir->dir_handle);
 575
 576                 if (!ent)
 577                 {
 578                         merge_new(dir);
 579                         sweep_deleted(dir);
 580
 581                         if (dir->needs_update)
 582                         {
 583                                 mc_seekdir(dir->dir_handle, dir->dir_start);
 584                                 init_for_scan(dir);
 585                                 return TRUE;
 586                         }
 587
 588                         mc_closedir(dir->dir_handle);
 589                         dir->dir_handle = NULL;
 590
 591                         return FALSE;           /* Stop */
 592                 }
 593
 594                 insert_item(dir, ent);
 595
 596         } while (!gtk_events_pending());
 597
 598         return TRUE;
 599 }
 600
 601 static Directory *load(char *pathname, gpointer data)
 602 {
 603         Directory *dir;
 604
 605         dir = g_new(Directory, 1);
 606         dir->ref = 1;
 607         dir->items = g_ptr_array_new();
 608         dir->new_items = g_ptr_array_new();
 609         dir->up_items = g_ptr_array_new();
 610         dir->users = NULL;
 611         dir->dir_handle = NULL;
 612         dir->needs_update = TRUE;
 613         dir->notify_active = FALSE;
 614         dir->pathname = g_strdup(pathname);
 615         dir->error = NULL;
 616
 617         return dir;
 618 }
 619
 620 static void destroy(Directory *dir)
 621 {
 622         g_return_if_fail(dir->users == NULL);
 623
 624         g_print("[ destroy %p ]\n", dir);
 625         if (dir->dir_handle)
 626         {
 627                 mc_closedir(dir->dir_handle);
 628                 gtk_idle_remove(dir->idle);
 629         }
 630         g_ptr_array_free(dir->up_items, TRUE);
 631         free_items_array(dir->items);
 632         free_items_array(dir->new_items);
 633         g_free(dir->error);
 634         g_free(dir->pathname);
 635         g_free(dir);
 636 }
 637
 638 static void ref(Directory *dir, gpointer data)
 639 {
 640         dir->ref++;
 641 }
 642
 643 static void unref(Directory *dir, gpointer data)
 644 {
 645         if (--dir->ref == 0)
 646                 destroy(dir);
 647 }
 648
 649 static int getref(Directory *dir, gpointer data)
 650 {
 651         return dir->ref;
 652 }
 653
 654 static void update(Directory *dir, gchar *pathname, gpointer data)
 655 {
 656         g_free(dir->pathname);
 657         dir->pathname = g_strdup(pathname);
 658
 659         start_scanning(dir, pathname);
 660
 661         if (dir->error)
 662                 delayed_error(PROJECT, dir->error);
 663 }
 664