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