ROX-Filer/src/dir.c

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