lib/vfs/direntry.c

   1 /** \file
   2  *  \brief Source: directory cache support
   3  *
   4  *  So that you do not have copy of this in each and every filesystem.
   5  *
   6  *  Very loosely based on tar.c from midnight and archives.[ch] from
   7  *  avfs by Miklos Szeredi (mszeredi@inf.bme.hu)
   8  *
   9  *  Unfortunately, I was unable to keep all filesystems
  10  *  uniform. tar-like filesystems use tree structure where each
  11  *  directory has pointers to its subdirectories. We can do this
  12  *  because we have full information about our archive.
  13  *
  14  *  At ftp-like filesystems, situation is a little bit different. When
  15  *  you cd /usr/src/linux/drivers/char, you do _not_ want /usr,
  16  *  /usr/src, /usr/src/linux and /usr/src/linux/drivers to be
  17  *  listed. That means that we do not have complete information, and if
  18  *  /usr is symlink to /4, we will not know. Also we have to time out
  19  *  entries and things would get messy with tree-like approach. So we
  20  *  do different trick: root directory is completely special and
  21  *  completely fake, it contains entries such as 'usr', 'usr/src', ...,
  22  *  and we'll try to use custom find_entry function.
  23  *
  24  *  \author Pavel Machek <pavel@ucw.cz>, distribute under LGPL.
  25  *  \date 1998
  26  *
  27  *  \warning Paths here do _not_ begin with '/', so root directory of
  28  *  archive/site is simply "".
  29  */
  30
  31 #include <config.h>
  32
  33 #include <errno.h>
  34 #include <fcntl.h>              /* include fcntl.h -> sys/fcntl.h only       */
  35                                 /* includes fcntl.h see IEEE Std 1003.1-2008 */
  36 #include <time.h>
  37 #include <sys/time.h>           /* gettimeofday() */
  38 #include <inttypes.h>           /* uintmax_t */
  39 #include <stdarg.h>
  40
  41 #include "lib/global.h"
  42
  43 #include "lib/tty/tty.h"        /* enable/disable interrupt key */
  44 #include "lib/util.h"           /* concat_dir_and_file */
  45 #if 0
  46 #include "lib/widget.h"         /* message() */
  47 #endif
  48
  49 #include "vfs.h"
  50 #include "utilvfs.h"
  51 #include "xdirentry.h"
  52 #include "gc.h"                 /* vfs_rmstamp */
  53
  54 /*** global variables ****************************************************************************/
  55
  56 /*** file scope macro definitions ****************************************************************/
  57
  58 #define CALL(x) if (MEDATA->x) MEDATA->x
  59
  60 /*** file scope type declarations ****************************************************************/
  61
  62 struct dirhandle
  63 {
  64     GList *cur;
  65     struct vfs_s_inode *dir;
  66 };
  67
  68 /*** file scope variables ************************************************************************/
  69
  70 static volatile int total_inodes = 0, total_entries = 0;
  71
  72 /*** file scope functions ************************************************************************/
  73 /* --------------------------------------------------------------------------------------------- */
  74
  75 static int
  76 vfs_s_entry_compare (const void *a, const void *b)
  77 {
  78     const struct vfs_s_entry *e = (const struct vfs_s_entry *) a;
  79     const char *name = (const char *) b;
  80
  81     return strcmp (e->name, name);
  82 }
  83
  84 /* --------------------------------------------------------------------------------------------- */
  85
  86 static void
  87 vfs_s_free_inode (struct vfs_class *me, struct vfs_s_inode *ino)
  88 {
  89     if (ino == NULL)
  90         vfs_die ("Don't pass NULL to me");
  91
  92     /* ==0 can happen if freshly created entry is deleted */
  93     if (ino->st.st_nlink > 1)
  94     {
  95         ino->st.st_nlink--;
  96         return;
  97     }
  98
  99     while (ino->subdir != NULL)
 100         vfs_s_free_entry (me, (struct vfs_s_entry *) ino->subdir->data);
 101
 102     CALL (free_inode) (me, ino);
 103     g_free (ino->linkname);
 104     if (ino->localname != NULL)
 105     {
 106         unlink (ino->localname);
 107         g_free (ino->localname);
 108     }
 109     total_inodes--;
 110     ino->super->ino_usage--;
 111     g_free (ino);
 112 }
 113
 114 /* --------------------------------------------------------------------------------------------- */
 115 /* We were asked to create entries automagically */
 116
 117 static struct vfs_s_entry *
 118 vfs_s_automake (struct vfs_class *me, struct vfs_s_inode *dir, char *path, int flags)
 119 {
 120     struct vfs_s_entry *res;
 121     char *sep;
 122
 123     sep = strchr (path, PATH_SEP);
 124     if (sep != NULL)
 125         *sep = '\0';
 126
 127     res = vfs_s_generate_entry (me, path, dir, flags & FL_MKDIR ? (0777 | S_IFDIR) : 0777);
 128     vfs_s_insert_entry (me, dir, res);
 129
 130     if (sep != NULL)
 131         *sep = PATH_SEP;
 132
 133     return res;
 134 }
 135
 136 /* --------------------------------------------------------------------------------------------- */
 137 /* If the entry is a symlink, find the entry for its target */
 138
 139 static struct vfs_s_entry *
 140 vfs_s_resolve_symlink (struct vfs_class *me, struct vfs_s_entry *entry, int follow)
 141 {
 142     char *linkname;
 143     char *fullname = NULL;
 144     struct vfs_s_entry *target;
 145
 146     if (follow == LINK_NO_FOLLOW)
 147         return entry;
 148     if (follow == 0)
 149         ERRNOR (ELOOP, NULL);
 150     if (!entry)
 151         ERRNOR (ENOENT, NULL);
 152     if (!S_ISLNK (entry->ino->st.st_mode))
 153         return entry;
 154
 155     linkname = entry->ino->linkname;
 156     if (linkname == NULL)
 157         ERRNOR (EFAULT, NULL);
 158
 159     /* make full path from relative */
 160     if (*linkname != PATH_SEP)
 161     {
 162         char *fullpath = vfs_s_fullpath (me, entry->dir);
 163         if (fullpath)
 164         {
 165             fullname = g_strconcat (fullpath, "/", linkname, (char *) NULL);
 166             linkname = fullname;
 167             g_free (fullpath);
 168         }
 169     }
 170
 171     target = (MEDATA->find_entry) (me, entry->dir->super->root, linkname, follow - 1, 0);
 172     g_free (fullname);
 173     return target;
 174 }
 175
 176 /* --------------------------------------------------------------------------------------------- */
 177 /*
 178  * Follow > 0: follow links, serves as loop protect,
 179  *       == -1: do not follow links
 180  */
 181
 182 static struct vfs_s_entry *
 183 vfs_s_find_entry_tree (struct vfs_class *me, struct vfs_s_inode *root,
 184                        const char *a_path, int follow, int flags)
 185 {
 186     size_t pseg;
 187     struct vfs_s_entry *ent = NULL;
 188     char *const pathref = g_strdup (a_path);
 189     char *path = pathref;
 190
 191     /* canonicalize as well, but don't remove '../' from path */
 192     custom_canonicalize_pathname (path, CANON_PATH_ALL & (~CANON_PATH_REMDOUBLEDOTS));
 193
 194     while (root != NULL)
 195     {
 196         GList *iter;
 197
 198         while (*path == PATH_SEP)       /* Strip leading '/' */
 199             path++;
 200
 201         if (path[0] == '\0')
 202         {
 203             g_free (pathref);
 204             return ent;
 205         }
 206
 207         for (pseg = 0; path[pseg] != '\0' && path[pseg] != PATH_SEP; pseg++)
 208             ;
 209
 210         for (iter = root->subdir; iter != NULL; iter = g_list_next (iter))
 211         {
 212             ent = (struct vfs_s_entry *) iter->data;
 213             if (strlen (ent->name) == pseg && strncmp (ent->name, path, pseg) == 0)
 214                 /* FOUND! */
 215                 break;
 216         }
 217
 218         ent = iter != NULL ? (struct vfs_s_entry *) iter->data : NULL;
 219
 220         if (ent == NULL && (flags & (FL_MKFILE | FL_MKDIR)) != 0)
 221             ent = vfs_s_automake (me, root, path, flags);
 222         if (ent == NULL)
 223         {
 224             me->verrno = ENOENT;
 225             goto cleanup;
 226         }
 227
 228         path += pseg;
 229         /* here we must follow leading directories always;
 230            only the actual file is optional */
 231         ent = vfs_s_resolve_symlink (me, ent,
 232                                      strchr (path, PATH_SEP) != NULL ? LINK_FOLLOW : follow);
 233         if (ent == NULL)
 234             goto cleanup;
 235         root = ent->ino;
 236     }
 237   cleanup:
 238     g_free (pathref);
 239     return NULL;
 240 }
 241
 242 /* --------------------------------------------------------------------------------------------- */
 243
 244 static void
 245 split_dir_name (struct vfs_class *me, char *path, char **dir, char **name, char **save)
 246 {
 247     char *s;
 248
 249     (void) me;
 250
 251     s = strrchr (path, PATH_SEP);
 252     if (s == NULL)
 253     {
 254         *save = NULL;
 255         *name = path;
 256         *dir = path + strlen (path);    /* an empty string */
 257     }
 258     else
 259     {
 260         *save = s;
 261         *dir = path;
 262         *s++ = '\0';
 263         *name = s;
 264     }
 265 }
 266
 267 /* --------------------------------------------------------------------------------------------- */
 268
 269 static struct vfs_s_entry *
 270 vfs_s_find_entry_linear (struct vfs_class *me, struct vfs_s_inode *root,
 271                          const char *a_path, int follow, int flags)
 272 {
 273     struct vfs_s_entry *ent = NULL;
 274     char *const path = g_strdup (a_path);
 275     struct vfs_s_entry *retval = NULL;
 276     GList *iter;
 277
 278     if (root->super->root != root)
 279         vfs_die ("We have to use _real_ root. Always. Sorry.");
 280
 281     /* canonicalize as well, but don't remove '../' from path */
 282     custom_canonicalize_pathname (path, CANON_PATH_ALL & (~CANON_PATH_REMDOUBLEDOTS));
 283
 284     if ((flags & FL_DIR) == 0)
 285     {
 286         char *dirname, *name, *save;
 287         struct vfs_s_inode *ino;
 288         split_dir_name (me, path, &dirname, &name, &save);
 289         ino = vfs_s_find_inode (me, root->super, dirname, follow, flags | FL_DIR);
 290         if (save != NULL)
 291             *save = PATH_SEP;
 292         retval = vfs_s_find_entry_tree (me, ino, name, follow, flags);
 293         g_free (path);
 294         return retval;
 295     }
 296
 297     iter = g_list_find_custom (root->subdir, path, (GCompareFunc) vfs_s_entry_compare);
 298     ent = iter != NULL ? (struct vfs_s_entry *) iter->data : NULL;
 299
 300     if (ent != NULL && !MEDATA->dir_uptodate (me, ent->ino))
 301     {
 302 #if 1
 303         vfs_print_message (_("Directory cache expired for %s"), path);
 304 #endif
 305         vfs_s_free_entry (me, ent);
 306         ent = NULL;
 307     }
 308
 309     if (ent == NULL)
 310     {
 311         struct vfs_s_inode *ino;
 312
 313         ino = vfs_s_new_inode (me, root->super, vfs_s_default_stat (me, S_IFDIR | 0755));
 314         ent = vfs_s_new_entry (me, path, ino);
 315         if (MEDATA->dir_load (me, ino, path) == -1)
 316         {
 317             vfs_s_free_entry (me, ent);
 318             g_free (path);
 319             return NULL;
 320         }
 321
 322         vfs_s_insert_entry (me, root, ent);
 323
 324         iter = g_list_find_custom (root->subdir, path, (GCompareFunc) vfs_s_entry_compare);
 325         ent = iter != NULL ? (struct vfs_s_entry *) iter->data : NULL;
 326     }
 327     if (ent == NULL)
 328         vfs_die ("find_linear: success but directory is not there\n");
 329
 330 #if 0
 331     if (!vfs_s_resolve_symlink (me, ent, follow))
 332     {
 333         g_free (path);
 334         return NULL;
 335     }
 336 #endif
 337     g_free (path);
 338     return ent;
 339 }
 340
 341 /* --------------------------------------------------------------------------------------------- */
 342 /* Ook, these were functions around directory entries / inodes */
 343 /* -------------------------------- superblock games -------------------------- */
 344
 345 static struct vfs_s_super *
 346 vfs_s_new_super (struct vfs_class *me)
 347 {
 348     struct vfs_s_super *super;
 349
 350     super = g_new0 (struct vfs_s_super, 1);
 351     super->me = me;
 352     return super;
 353 }
 354
 355 /* --------------------------------------------------------------------------------------------- */
 356
 357 static inline void
 358 vfs_s_insert_super (struct vfs_class *me, struct vfs_s_super *super)
 359 {
 360     MEDATA->supers = g_list_prepend (MEDATA->supers, super);
 361 }
 362
 363 /* --------------------------------------------------------------------------------------------- */
 364
 365 static void
 366 vfs_s_free_super (struct vfs_class *me, struct vfs_s_super *super)
 367 {
 368     if (super->root != NULL)
 369     {
 370         vfs_s_free_inode (me, super->root);
 371         super->root = NULL;
 372     }
 373
 374 #if 0
 375     /* FIXME: We currently leak small ammount of memory, sometimes. Fix it if you can. */
 376     if (super->ino_usage)
 377         message (D_ERROR, "Direntry warning",
 378                  "Super ino_usage is %d, memory leak", super->ino_usage);
 379
 380     if (super->want_stale)
 381         message (D_ERROR, "Direntry warning", "%s", "Super has want_stale set");
 382 #endif
 383
 384     MEDATA->supers = g_list_remove (MEDATA->supers, super);
 385
 386     CALL (free_archive) (me, super);
 387 #ifdef ENABLE_VFS_NET
 388     vfs_url_free (super->url);
 389 #endif
 390     g_free (super->name);
 391     g_free (super);
 392 }
 393
 394 /* --------------------------------------------------------------------------------------------- */
 395 /**
 396  * Dissect the path and create corresponding superblock.
 397  * The result should be freed.
 398  */
 399
 400 static char *
 401 vfs_s_get_path (struct vfs_class *me, const char *inname, struct vfs_s_super **archive, int flags)
 402 {
 403     char *buf, *retval;
 404
 405     buf = g_strdup (inname);
 406     retval = g_strdup (vfs_s_get_path_mangle (me, buf, archive, flags));
 407     g_free (buf);
 408     return retval;
 409 }
 410
 411 /* --------------------------------------------------------------------------------------------- */
 412 /* Support of archives */
 413 /* ------------------------ readdir & friends ----------------------------- */
 414
 415 static struct vfs_s_inode *
 416 vfs_s_inode_from_path (struct vfs_class *me, const char *name, int flags)
 417 {
 418     struct vfs_s_super *super;
 419     struct vfs_s_inode *ino;
 420     char *q;
 421
 422     if (!(q = vfs_s_get_path (me, name, &super, 0)))
 423         return NULL;
 424
 425     ino =
 426         vfs_s_find_inode (me, super, q,
 427                           flags & FL_FOLLOW ? LINK_FOLLOW : LINK_NO_FOLLOW, flags & ~FL_FOLLOW);
 428     if ((!ino) && (!*q))
 429         /* We are asking about / directory of ftp server: assume it exists */
 430         ino =
 431             vfs_s_find_inode (me, super, q,
 432                               flags & FL_FOLLOW ? LINK_FOLLOW :
 433                               LINK_NO_FOLLOW, FL_DIR | (flags & ~FL_FOLLOW));
 434     g_free (q);
 435     return ino;
 436 }
 437
 438 /* --------------------------------------------------------------------------------------------- */
 439
 440 static void *
 441 vfs_s_opendir (struct vfs_class *me, const char *dirname)
 442 {
 443     struct vfs_s_inode *dir;
 444     struct dirhandle *info;
 445
 446     dir = vfs_s_inode_from_path (me, dirname, FL_DIR | FL_FOLLOW);
 447     if (dir == NULL)
 448         return NULL;
 449     if (!S_ISDIR (dir->st.st_mode))
 450         ERRNOR (ENOTDIR, NULL);
 451
 452     dir->st.st_nlink++;
 453 #if 0
 454     if (dir->subdir == NULL)    /* This can actually happen if we allow empty directories */
 455         ERRNOR (EAGAIN, NULL);
 456 #endif
 457     info = g_new (struct dirhandle, 1);
 458     info->cur = dir->subdir;
 459     info->dir = dir;
 460
 461     return info;
 462 }
 463
 464 /* --------------------------------------------------------------------------------------------- */
 465
 466 static void *
 467 vfs_s_readdir (void *data)
 468 {
 469     static union vfs_dirent dir;
 470     struct dirhandle *info = (struct dirhandle *) data;
 471     const char *name;
 472
 473     if (info->cur == NULL || info->cur->data == NULL)
 474         return NULL;
 475
 476     name = ((struct vfs_s_entry *) info->cur->data)->name;
 477     if (name != NULL)
 478         g_strlcpy (dir.dent.d_name, name, MC_MAXPATHLEN);
 479     else
 480         vfs_die ("Null in structure-cannot happen");
 481
 482     compute_namelen (&dir.dent);
 483     info->cur = g_list_next (info->cur);
 484
 485     return (void *) &dir;
 486 }
 487
 488 /* --------------------------------------------------------------------------------------------- */
 489
 490 static int
 491 vfs_s_closedir (void *data)
 492 {
 493     struct dirhandle *info = (struct dirhandle *) data;
 494     struct vfs_s_inode *dir = info->dir;
 495
 496     vfs_s_free_inode (dir->super->me, dir);
 497     g_free (data);
 498     return 0;
 499 }
 500
 501 /* --------------------------------------------------------------------------------------------- */
 502
 503 static int
 504 vfs_s_chdir (struct vfs_class *me, const char *path)
 505 {
 506     void *data;
 507
 508     data = vfs_s_opendir (me, path);
 509     if (data == NULL)
 510         return -1;
 511     vfs_s_closedir (data);
 512     return 0;
 513 }
 514
 515 /* --------------------------------------------------------------------------------------------- */
 516 /* --------------------------- stat and friends ---------------------------- */
 517
 518 static int
 519 vfs_s_internal_stat (struct vfs_class *me, const char *path, struct stat *buf, int flag)
 520 {
 521     struct vfs_s_inode *ino;
 522
 523     ino = vfs_s_inode_from_path (me, path, flag);
 524     if (ino == NULL)
 525         return -1;
 526     *buf = ino->st;
 527     return 0;
 528 }
 529
 530 /* --------------------------------------------------------------------------------------------- */
 531
 532 static int
 533 vfs_s_stat (struct vfs_class *me, const char *path, struct stat *buf)
 534 {
 535     return vfs_s_internal_stat (me, path, buf, FL_FOLLOW);
 536 }
 537
 538 /* --------------------------------------------------------------------------------------------- */
 539
 540 static int
 541 vfs_s_lstat (struct vfs_class *me, const char *path, struct stat *buf)
 542 {
 543     return vfs_s_internal_stat (me, path, buf, FL_NONE);
 544 }
 545
 546 /* --------------------------------------------------------------------------------------------- */
 547
 548 static int
 549 vfs_s_fstat (void *fh, struct stat *buf)
 550 {
 551     *buf = FH->ino->st;
 552     return 0;
 553 }
 554
 555 /* --------------------------------------------------------------------------------------------- */
 556
 557 static int
 558 vfs_s_readlink (struct vfs_class *me, const char *path, char *buf, size_t size)
 559 {
 560     struct vfs_s_inode *ino;
 561     size_t len;
 562
 563     ino = vfs_s_inode_from_path (me, path, 0);
 564     if (!ino)
 565         return -1;
 566
 567     if (!S_ISLNK (ino->st.st_mode))
 568         ERRNOR (EINVAL, -1);
 569
 570     if (ino->linkname == NULL)
 571         ERRNOR (EFAULT, -1);
 572
 573     len = strlen (ino->linkname);
 574     if (size < len)
 575         len = size;
 576     /* readlink() does not append a NUL character to buf */
 577     memcpy (buf, ino->linkname, len);
 578     return len;
 579 }
 580
 581 /* --------------------------------------------------------------------------------------------- */
 582
 583 static ssize_t
 584 vfs_s_read (void *fh, char *buffer, size_t count)
 585 {
 586     int n;
 587     struct vfs_class *me = FH_SUPER->me;
 588
 589     if (FH->linear == LS_LINEAR_PREOPEN)
 590     {
 591         if (!MEDATA->linear_start (me, FH, FH->pos))
 592             return -1;
 593     }
 594
 595     if (FH->linear == LS_LINEAR_CLOSED)
 596         vfs_die ("linear_start() did not set linear_state!");
 597
 598     if (FH->linear == LS_LINEAR_OPEN)
 599         return MEDATA->linear_read (me, FH, buffer, count);
 600
 601     if (FH->handle != -1)
 602     {
 603         n = read (FH->handle, buffer, count);
 604         if (n < 0)
 605             me->verrno = errno;
 606         return n;
 607     }
 608     vfs_die ("vfs_s_read: This should not happen\n");
 609     return -1;
 610 }
 611
 612 /* --------------------------------------------------------------------------------------------- */
 613
 614 static ssize_t
 615 vfs_s_write (void *fh, const char *buffer, size_t count)
 616 {
 617     int n;
 618     struct vfs_class *me = FH_SUPER->me;
 619
 620     if (FH->linear)
 621         vfs_die ("no writing to linear files, please");
 622
 623     FH->changed = 1;
 624     if (FH->handle != -1)
 625     {
 626         n = write (FH->handle, buffer, count);
 627         if (n < 0)
 628             me->verrno = errno;
 629         return n;
 630     }
 631     vfs_die ("vfs_s_write: This should not happen\n");
 632     return 0;
 633 }
 634
 635 /* --------------------------------------------------------------------------------------------- */
 636
 637 static off_t
 638 vfs_s_lseek (void *fh, off_t offset, int whence)
 639 {
 640     off_t size = FH->ino->st.st_size;
 641
 642     if (FH->linear == LS_LINEAR_OPEN)
 643         vfs_die ("cannot lseek() after linear_read!");
 644
 645     if (FH->handle != -1)
 646     {                           /* If we have local file opened, we want to work with it */
 647         off_t retval = lseek (FH->handle, offset, whence);
 648         if (retval == -1)
 649             FH->ino->super->me->verrno = errno;
 650         return retval;
 651     }
 652
 653     switch (whence)
 654     {
 655     case SEEK_CUR:
 656         offset += FH->pos;
 657         break;
 658     case SEEK_END:
 659         offset += size;
 660         break;
 661     }
 662     if (offset < 0)
 663         FH->pos = 0;
 664     else if (offset < size)
 665         FH->pos = offset;
 666     else
 667         FH->pos = size;
 668     return FH->pos;
 669 }
 670
 671 /* --------------------------------------------------------------------------------------------- */
 672
 673 static int
 674 vfs_s_close (void *fh)
 675 {
 676     int res = 0;
 677     struct vfs_class *me = FH_SUPER->me;
 678
 679     FH_SUPER->fd_usage--;
 680     if (!FH_SUPER->fd_usage)
 681         vfs_stamp_create (me, FH_SUPER);
 682
 683     if (FH->linear == LS_LINEAR_OPEN)
 684         MEDATA->linear_close (me, fh);
 685     if (MEDATA->fh_close)
 686         res = MEDATA->fh_close (me, fh);
 687     if (FH->changed && MEDATA->file_store)
 688     {
 689         char *s = vfs_s_fullpath (me, FH->ino);
 690         if (!s)
 691             res = -1;
 692         else
 693         {
 694             res = MEDATA->file_store (me, fh, s, FH->ino->localname);
 695             g_free (s);
 696         }
 697         vfs_s_invalidate (me, FH_SUPER);
 698     }
 699     if (FH->handle != -1)
 700         close (FH->handle);
 701
 702     vfs_s_free_inode (me, FH->ino);
 703     g_free (fh);
 704     return res;
 705 }
 706
 707 /* --------------------------------------------------------------------------------------------- */
 708
 709 static void
 710 vfs_s_print_stats (const char *fs_name, const char *action,
 711                    const char *file_name, off_t have, off_t need)
 712 {
 713     static const char *i18n_percent_transf_format = NULL;
 714     static const char *i18n_transf_format = NULL;
 715
 716     if (i18n_percent_transf_format == NULL)
 717     {
 718         i18n_percent_transf_format = "%s: %s: %s %3d%% (%" PRIuMAX " %s";
 719         i18n_transf_format = "%s: %s: %s %" PRIuMAX " %s";
 720     }
 721
 722     if (need)
 723         vfs_print_message (i18n_percent_transf_format, fs_name, action,
 724                            file_name, (int) ((double) have * 100 / need), (uintmax_t) have,
 725                            _("bytes transferred"));
 726     else
 727         vfs_print_message (i18n_transf_format, fs_name, action, file_name, (uintmax_t) have,
 728                            _("bytes transferred"));
 729 }
 730
 731 /* --------------------------------------------------------------------------------------------- */
 732 /* ------------------------------- mc support ---------------------------- */
 733
 734 static void
 735 vfs_s_fill_names (struct vfs_class *me, fill_names_f func)
 736 {
 737     GList *iter;
 738
 739     for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
 740     {
 741         const struct vfs_s_super *super = (const struct vfs_s_super *) iter->data;
 742         char *name;
 743
 744         name = g_strconcat (super->name, "#", me->prefix, "/",
 745                             /* super->current_dir->name, */ (char *) NULL);
 746         func (name);
 747         g_free (name);
 748     }
 749 }
 750
 751 /* --------------------------------------------------------------------------------------------- */
 752
 753 static int
 754 vfs_s_ferrno (struct vfs_class *me)
 755 {
 756     return me->verrno;
 757 }
 758
 759 /* --------------------------------------------------------------------------------------------- */
 760 /**
 761  * Get local copy of the given file.  We reuse the existing file cache
 762  * for remote filesystems.  Archives use standard VFS facilities.
 763  */
 764
 765 static char *
 766 vfs_s_getlocalcopy (const vfs_path_t * vpath)
 767 {
 768     vfs_file_handler_t *fh;
 769     char *local = NULL;
 770
 771     fh = vfs_s_open (vpath, O_RDONLY, 0);
 772
 773     if (fh != NULL)
 774     {
 775         if ((fh->ino != NULL) && (fh->ino->localname != NULL))
 776             local = g_strdup (fh->ino->localname);
 777
 778         vfs_s_close (fh);
 779     }
 780
 781     return local;
 782 }
 783
 784 /* --------------------------------------------------------------------------------------------- */
 785 /**
 786  * Return the local copy.  Since we are using our cache, we do nothing -
 787  * the cache will be removed when the archive is closed.
 788  */
 789
 790 static int
 791 vfs_s_ungetlocalcopy (const vfs_path_t * vpath, const char *local, int has_changed)
 792 {
 793     (void) vpath;
 794     (void) local;
 795     (void) has_changed;
 796     return 0;
 797 }
 798
 799 /* --------------------------------------------------------------------------------------------- */
 800
 801 static int
 802 vfs_s_setctl (struct vfs_class *me, const char *path, int ctlop, void *arg)
 803 {
 804     switch (ctlop)
 805     {
 806     case VFS_SETCTL_STALE_DATA:
 807         {
 808             struct vfs_s_inode *ino = vfs_s_inode_from_path (me, path, 0);
 809
 810             if (ino == NULL)
 811                 return 0;
 812             if (arg)
 813                 ino->super->want_stale = 1;
 814             else
 815             {
 816                 ino->super->want_stale = 0;
 817                 vfs_s_invalidate (me, ino->super);
 818             }
 819             return 1;
 820         }
 821     case VFS_SETCTL_LOGFILE:
 822         MEDATA->logfile = fopen ((char *) arg, "w");
 823         return 1;
 824     case VFS_SETCTL_FLUSH:
 825         MEDATA->flush = 1;
 826         return 1;
 827     }
 828     return 0;
 829 }
 830
 831 /* --------------------------------------------------------------------------------------------- */
 832 /* ----------------------------- Stamping support -------------------------- */
 833
 834 static vfsid
 835 vfs_s_getid (struct vfs_class *me, const char *path)
 836 {
 837     struct vfs_s_super *archive = NULL;
 838     char *p;
 839
 840     p = vfs_s_get_path (me, path, &archive, FL_NO_OPEN);
 841     if (p == NULL)
 842         return NULL;
 843     g_free (p);
 844     return (vfsid) archive;
 845 }
 846
 847 /* --------------------------------------------------------------------------------------------- */
 848
 849 static int
 850 vfs_s_nothingisopen (vfsid id)
 851 {
 852     (void) id;
 853     /* Our data structures should survive free of superblock at any time */
 854     return 1;
 855 }
 856
 857 /* --------------------------------------------------------------------------------------------- */
 858
 859 static void
 860 vfs_s_free (vfsid id)
 861 {
 862     vfs_s_free_super (((struct vfs_s_super *) id)->me, (struct vfs_s_super *) id);
 863 }
 864
 865 /* --------------------------------------------------------------------------------------------- */
 866
 867 static int
 868 vfs_s_dir_uptodate (struct vfs_class *me, struct vfs_s_inode *ino)
 869 {
 870     struct timeval tim;
 871
 872     if (MEDATA->flush)
 873     {
 874         MEDATA->flush = 0;
 875         return 0;
 876     }
 877
 878     gettimeofday (&tim, NULL);
 879     if (tim.tv_sec < ino->timestamp.tv_sec)
 880         return 1;
 881     return 0;
 882 }
 883
 884
 885 /* --------------------------------------------------------------------------------------------- */
 886 /*** public functions ****************************************************************************/
 887 /* --------------------------------------------------------------------------------------------- */
 888
 889 struct vfs_s_inode *
 890 vfs_s_new_inode (struct vfs_class *me, struct vfs_s_super *super, struct stat *initstat)
 891 {
 892     struct vfs_s_inode *ino;
 893
 894     ino = g_try_new0 (struct vfs_s_inode, 1);
 895     if (ino == NULL)
 896         return NULL;
 897
 898     if (initstat)
 899         ino->st = *initstat;
 900     ino->super = super;
 901     ino->st.st_nlink = 0;
 902     ino->st.st_ino = MEDATA->inode_counter++;
 903     ino->st.st_dev = MEDATA->rdev;
 904
 905     super->ino_usage++;
 906     total_inodes++;
 907
 908     CALL (init_inode) (me, ino);
 909
 910     return ino;
 911 }
 912
 913 /* --------------------------------------------------------------------------------------------- */
 914
 915 struct vfs_s_entry *
 916 vfs_s_new_entry (struct vfs_class *me, const char *name, struct vfs_s_inode *inode)
 917 {
 918     struct vfs_s_entry *entry;
 919
 920     entry = g_new0 (struct vfs_s_entry, 1);
 921     total_entries++;
 922
 923     entry->name = g_strdup (name);
 924     entry->ino = inode;
 925     entry->ino->ent = entry;
 926     CALL (init_entry) (me, entry);
 927
 928     return entry;
 929 }
 930
 931
 932 /* --------------------------------------------------------------------------------------------- */
 933
 934 void
 935 vfs_s_free_entry (struct vfs_class *me, struct vfs_s_entry *ent)
 936 {
 937     if (ent->dir != NULL)
 938         ent->dir->subdir = g_list_remove (ent->dir->subdir, ent);
 939
 940     g_free (ent->name);
 941     /* ent->name = NULL; */
 942
 943     if (ent->ino != NULL)
 944     {
 945         ent->ino->ent = NULL;
 946         vfs_s_free_inode (me, ent->ino);
 947     }
 948
 949     total_entries--;
 950     g_free (ent);
 951 }
 952
 953 /* --------------------------------------------------------------------------------------------- */
 954
 955 void
 956 vfs_s_insert_entry (struct vfs_class *me, struct vfs_s_inode *dir, struct vfs_s_entry *ent)
 957 {
 958     (void) me;
 959
 960     ent->dir = dir;
 961
 962     ent->ino->st.st_nlink++;
 963     dir->subdir = g_list_append (dir->subdir, ent);
 964 }
 965
 966 /* --------------------------------------------------------------------------------------------- */
 967
 968 struct stat *
 969 vfs_s_default_stat (struct vfs_class *me, mode_t mode)
 970 {
 971     static struct stat st;
 972     int myumask;
 973
 974     (void) me;
 975
 976     myumask = umask (022);
 977     umask (myumask);
 978     mode &= ~myumask;
 979
 980     st.st_mode = mode;
 981     st.st_ino = 0;
 982     st.st_dev = 0;
 983     st.st_rdev = 0;
 984     st.st_uid = getuid ();
 985     st.st_gid = getgid ();
 986     st.st_size = 0;
 987     st.st_mtime = st.st_atime = st.st_ctime = time (NULL);
 988
 989     return &st;
 990 }
 991
 992 /* --------------------------------------------------------------------------------------------- */
 993
 994 struct vfs_s_entry *
 995 vfs_s_generate_entry (struct vfs_class *me, const char *name, struct vfs_s_inode *parent,
 996                       mode_t mode)
 997 {
 998     struct vfs_s_inode *inode;
 999     struct stat *st;
1000
1001     st = vfs_s_default_stat (me, mode);
1002     inode = vfs_s_new_inode (me, parent->super, st);
1003
1004     return vfs_s_new_entry (me, name, inode);
1005 }
1006
1007 /* --------------------------------------------------------------------------------------------- */
1008
1009 struct vfs_s_inode *
1010 vfs_s_find_inode (struct vfs_class *me, const struct vfs_s_super *super,
1011                   const char *path, int follow, int flags)
1012 {
1013     struct vfs_s_entry *ent;
1014
1015     if (((MEDATA->flags & VFS_S_REMOTE) == 0) && (*path == '\0'))
1016         return super->root;
1017
1018     ent = (MEDATA->find_entry) (me, super->root, path, follow, flags);
1019     return (ent != NULL) ? ent->ino : NULL;
1020 }
1021
1022 /* --------------------------------------------------------------------------------------------- */
1023 /* Ook, these were functions around directory entries / inodes */
1024 /* -------------------------------- superblock games -------------------------- */
1025
1026 /*
1027  * Dissect the path and create corresponding superblock.  Note that inname
1028  * can be changed and the result may point inside the original string.
1029  */
1030 const char *
1031 vfs_s_get_path_mangle (struct vfs_class *me, char *inname, struct vfs_s_super **archive, int flags)
1032 {
1033     GList *iter;
1034     const char *retval;
1035     char *local, *op;
1036     const char *archive_name;
1037     int result = -1;
1038     struct vfs_s_super *super;
1039     void *cookie = NULL;
1040
1041     archive_name = inname;
1042     vfs_split (inname, &local, &op);
1043     retval = (local != NULL) ? local : "";
1044
1045     if (MEDATA->archive_check != NULL)
1046     {
1047         cookie = MEDATA->archive_check (me, archive_name, op);
1048         if (cookie == NULL)
1049             return NULL;
1050     }
1051
1052     for (iter = MEDATA->supers; iter != NULL; iter = g_list_next (iter))
1053     {
1054         int i;
1055
1056         super = (struct vfs_s_super *) iter->data;
1057
1058         /* 0 == other, 1 == same, return it, 2 == other but stop scanning */
1059         i = MEDATA->archive_same (me, super, archive_name, op, cookie);
1060         if (i != 0)
1061         {
1062             if (i == 1)
1063                 goto return_success;
1064             break;
1065         }
1066     }
1067
1068     if (flags & FL_NO_OPEN)
1069         ERRNOR (EIO, NULL);
1070
1071     super = vfs_s_new_super (me);
1072     if (MEDATA->open_archive != NULL)
1073         result = MEDATA->open_archive (me, super, archive_name, op);
1074     if (result == -1)
1075     {
1076         vfs_s_free_super (me, super);
1077         ERRNOR (EIO, NULL);
1078     }
1079     if (!super->name)
1080         vfs_die ("You have to fill name\n");
1081     if (!super->root)
1082         vfs_die ("You have to fill root inode\n");
1083
1084     vfs_s_insert_super (me, super);
1085     vfs_stamp_create (me, super);
1086
1087   return_success:
1088     *archive = super;
1089     return retval;
1090 }
1091
1092 /* --------------------------------------------------------------------------------------------- */
1093
1094 void
1095 vfs_s_invalidate (struct vfs_class *me, struct vfs_s_super *super)
1096 {
1097     if (!super->want_stale)
1098     {
1099         vfs_s_free_inode (me, super->root);
1100         super->root = vfs_s_new_inode (me, super, vfs_s_default_stat (me, S_IFDIR | 0755));
1101     }
1102 }
1103
1104 /* --------------------------------------------------------------------------------------------- */
1105
1106 char *
1107 vfs_s_fullpath (struct vfs_class *me, struct vfs_s_inode *ino)
1108 {
1109     if (!ino->ent)
1110         ERRNOR (EAGAIN, NULL);
1111
1112     if (!(MEDATA->flags & VFS_S_REMOTE))
1113     {
1114         /* archives */
1115         char *newpath;
1116         char *path = g_strdup (ino->ent->name);
1117         while (1)
1118         {
1119             ino = ino->ent->dir;
1120             if (ino == ino->super->root)
1121                 break;
1122             newpath = g_strconcat (ino->ent->name, "/", path, (char *) NULL);
1123             g_free (path);
1124             path = newpath;
1125         }
1126         return path;
1127     }
1128
1129     /* remote systems */
1130     if ((!ino->ent->dir) || (!ino->ent->dir->ent))
1131         return g_strdup (ino->ent->name);
1132
1133     return g_strconcat (ino->ent->dir->ent->name, PATH_SEP_STR, ino->ent->name, (char *) NULL);
1134 }
1135
1136 /* --------------------------------------------------------------------------------------------- */
1137 /* --------------------------- stat and friends ---------------------------- */
1138
1139 void *
1140 vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
1141 {
1142     int was_changed = 0;
1143     vfs_file_handler_t *fh;
1144     struct vfs_s_super *super;
1145     char *q;
1146     struct vfs_s_inode *ino;
1147     vfs_path_element_t *path_element;
1148
1149     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
1150
1151     q = vfs_s_get_path (path_element->class, vpath->unparsed, &super, 0);
1152     if (q == NULL)
1153         return NULL;
1154     ino = vfs_s_find_inode (path_element->class, super, q, LINK_FOLLOW, FL_NONE);
1155     if (ino && ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)))
1156     {
1157         g_free (q);
1158         path_element->class->verrno = EEXIST;
1159         return NULL;
1160     }
1161     if (!ino)
1162     {
1163         char *dirname, *name, *save;
1164         struct vfs_s_entry *ent;
1165         struct vfs_s_inode *dir;
1166         int tmp_handle;
1167
1168         /* If the filesystem is read-only, disable file creation */
1169         if (!(flags & O_CREAT) || !(path_element->class->write))
1170         {
1171             g_free (q);
1172             return NULL;
1173         }
1174
1175         split_dir_name (path_element->class, q, &dirname, &name, &save);
1176         dir = vfs_s_find_inode (path_element->class, super, dirname, LINK_FOLLOW, FL_DIR);
1177         if (dir == NULL)
1178         {
1179             g_free (q);
1180             return NULL;
1181         }
1182         if (save)
1183             *save = PATH_SEP;
1184         ent = vfs_s_generate_entry (path_element->class, name, dir, 0755);
1185         ino = ent->ino;
1186         vfs_s_insert_entry (path_element->class, dir, ent);
1187         tmp_handle = vfs_mkstemps (&ino->localname, path_element->class->name, name);
1188         if (tmp_handle == -1)
1189         {
1190             g_free (q);
1191             return NULL;
1192         }
1193         close (tmp_handle);
1194         was_changed = 1;
1195     }
1196
1197     g_free (q);
1198
1199     if (S_ISDIR (ino->st.st_mode))
1200     {
1201         path_element->class->verrno = EISDIR;
1202         return NULL;
1203     }
1204
1205     fh = g_new (vfs_file_handler_t, 1);
1206     fh->pos = 0;
1207     fh->ino = ino;
1208     fh->handle = -1;
1209     fh->changed = was_changed;
1210     fh->linear = 0;
1211     fh->data = NULL;
1212
1213     if (IS_LINEAR (flags))
1214     {
1215         if (VFSDATA (path_element)->linear_start)
1216         {
1217             vfs_print_message (_("Starting linear transfer..."));
1218             fh->linear = LS_LINEAR_PREOPEN;
1219         }
1220     }
1221     else if ((VFSDATA (path_element)->fh_open != NULL)
1222              && (VFSDATA (path_element)->fh_open (path_element->class, fh, flags, mode) != 0))
1223     {
1224         g_free (fh);
1225         return NULL;
1226     }
1227
1228     if (fh->ino->localname)
1229     {
1230         fh->handle = open (fh->ino->localname, NO_LINEAR (flags), mode);
1231         if (fh->handle == -1)
1232         {
1233             g_free (fh);
1234             path_element->class->verrno = errno;
1235             return NULL;
1236         }
1237     }
1238
1239     /* i.e. we had no open files and now we have one */
1240     vfs_rmstamp (path_element->class, (vfsid) super);
1241     super->fd_usage++;
1242     fh->ino->st.st_nlink++;
1243     return fh;
1244 }
1245
1246 /* --------------------------------------------------------------------------------------------- */
1247
1248 int
1249 vfs_s_retrieve_file (struct vfs_class *me, struct vfs_s_inode *ino)
1250 {
1251     /* If you want reget, you'll have to open file with O_LINEAR */
1252     off_t total = 0;
1253     char buffer[8192];
1254     int handle, n;
1255     off_t stat_size = ino->st.st_size;
1256     vfs_file_handler_t fh;
1257
1258     memset (&fh, 0, sizeof (fh));
1259
1260     fh.ino = ino;
1261     fh.handle = -1;
1262
1263     handle = vfs_mkstemps (&ino->localname, me->name, ino->ent->name);
1264     if (handle == -1)
1265     {
1266         me->verrno = errno;
1267         goto error_4;
1268     }
1269
1270     if (!MEDATA->linear_start (me, &fh, 0))
1271         goto error_3;
1272
1273     /* Clear the interrupt status */
1274     tty_got_interrupt ();
1275     tty_enable_interrupt_key ();
1276
1277     while ((n = MEDATA->linear_read (me, &fh, buffer, sizeof (buffer))))
1278     {
1279         int t;
1280         if (n < 0)
1281             goto error_1;
1282
1283         total += n;
1284         vfs_s_print_stats (me->name, _("Getting file"), ino->ent->name, total, stat_size);
1285
1286         if (tty_got_interrupt ())
1287             goto error_1;
1288
1289         t = write (handle, buffer, n);
1290         if (t != n)
1291         {
1292             if (t == -1)
1293                 me->verrno = errno;
1294             goto error_1;
1295         }
1296     }
1297     MEDATA->linear_close (me, &fh);
1298     close (handle);
1299
1300     tty_disable_interrupt_key ();
1301     g_free (fh.data);
1302     return 0;
1303
1304   error_1:
1305     MEDATA->linear_close (me, &fh);
1306   error_3:
1307     tty_disable_interrupt_key ();
1308     close (handle);
1309     unlink (ino->localname);
1310   error_4:
1311     g_free (ino->localname);
1312     ino->localname = NULL;
1313     g_free (fh.data);
1314     return -1;
1315 }
1316
1317 /* --------------------------------------------------------------------------------------------- */
1318 /* ----------------------------- Stamping support -------------------------- */
1319
1320 /* Initialize one of our subclasses - fill common functions */
1321 void
1322 vfs_s_init_class (struct vfs_class *vclass, struct vfs_s_subclass *sub)
1323 {
1324     vclass->data = sub;
1325     vclass->fill_names = vfs_s_fill_names;
1326     vclass->open = vfs_s_open;
1327     vclass->close = vfs_s_close;
1328     vclass->read = vfs_s_read;
1329     if (!(sub->flags & VFS_S_READONLY))
1330     {
1331         vclass->write = vfs_s_write;
1332     }
1333     vclass->opendir = vfs_s_opendir;
1334     vclass->readdir = vfs_s_readdir;
1335     vclass->closedir = vfs_s_closedir;
1336     vclass->stat = vfs_s_stat;
1337     vclass->lstat = vfs_s_lstat;
1338     vclass->fstat = vfs_s_fstat;
1339     vclass->readlink = vfs_s_readlink;
1340     vclass->chdir = vfs_s_chdir;
1341     vclass->ferrno = vfs_s_ferrno;
1342     vclass->lseek = vfs_s_lseek;
1343     vclass->getid = vfs_s_getid;
1344     vclass->nothingisopen = vfs_s_nothingisopen;
1345     vclass->free = vfs_s_free;
1346     if (sub->flags & VFS_S_REMOTE)
1347     {
1348         vclass->getlocalcopy = vfs_s_getlocalcopy;
1349         vclass->ungetlocalcopy = vfs_s_ungetlocalcopy;
1350         sub->find_entry = vfs_s_find_entry_linear;
1351     }
1352     else
1353     {
1354         sub->find_entry = vfs_s_find_entry_tree;
1355     }
1356     vclass->setctl = vfs_s_setctl;
1357     sub->dir_uptodate = vfs_s_dir_uptodate;
1358 }
1359
1360 /* --------------------------------------------------------------------------------------------- */
1361 /** Find VFS id for given directory name */
1362
1363 vfsid
1364 vfs_getid (struct vfs_class *vclass, const char *dir)
1365 {
1366     char *dir1;
1367     vfsid id = NULL;
1368
1369     /* append slash if needed */
1370     dir1 = concat_dir_and_file (dir, "");
1371     if (vclass->getid)
1372         id = (*vclass->getid) (vclass, dir1);
1373
1374     g_free (dir1);
1375     return id;
1376 }
1377
1378 /* --------------------------------------------------------------------------------------------- */
1379 /* ----------- Utility functions for networked filesystems  -------------- */
1380
1381 #ifdef ENABLE_VFS_NET
1382 int
1383 vfs_s_select_on_two (int fd1, int fd2)
1384 {
1385     fd_set set;
1386     struct timeval time_out;
1387     int v;
1388     int maxfd = (fd1 > fd2 ? fd1 : fd2) + 1;
1389
1390     time_out.tv_sec = 1;
1391     time_out.tv_usec = 0;
1392     FD_ZERO (&set);
1393     FD_SET (fd1, &set);
1394     FD_SET (fd2, &set);
1395     v = select (maxfd, &set, 0, 0, &time_out);
1396     if (v <= 0)
1397         return v;
1398     if (FD_ISSET (fd1, &set))
1399         return 1;
1400     if (FD_ISSET (fd2, &set))
1401         return 2;
1402     return -1;
1403 }
1404
1405 /* --------------------------------------------------------------------------------------------- */
1406
1407 int
1408 vfs_s_get_line (struct vfs_class *me, int sock, char *buf, int buf_len, char term)
1409 {
1410     FILE *logfile = MEDATA->logfile;
1411     int i;
1412     char c;
1413
1414     for (i = 0; i < buf_len - 1; i++, buf++)
1415     {
1416         if (read (sock, buf, sizeof (char)) <= 0)
1417             return 0;
1418         if (logfile)
1419         {
1420             size_t ret1;
1421             int ret2;
1422             ret1 = fwrite (buf, 1, 1, logfile);
1423             ret2 = fflush (logfile);
1424         }
1425         if (*buf == term)
1426         {
1427             *buf = 0;
1428             return 1;
1429         }
1430     }
1431
1432     /* Line is too long - terminate buffer and discard the rest of line */
1433     *buf = 0;
1434     while (read (sock, &c, sizeof (c)) > 0)
1435     {
1436         if (logfile)
1437         {
1438             size_t ret1;
1439             int ret2;
1440             ret1 = fwrite (&c, 1, 1, logfile);
1441             ret2 = fflush (logfile);
1442         }
1443         if (c == '\n')
1444             return 1;
1445     }
1446     return 0;
1447 }
1448
1449 /* --------------------------------------------------------------------------------------------- */
1450
1451 int
1452 vfs_s_get_line_interruptible (struct vfs_class *me, char *buffer, int size, int fd)
1453 {
1454     int n;
1455     int i;
1456
1457     (void) me;
1458
1459     tty_enable_interrupt_key ();
1460     for (i = 0; i < size - 1; i++)
1461     {
1462         n = read (fd, buffer + i, 1);
1463         tty_disable_interrupt_key ();
1464         if (n == -1 && errno == EINTR)
1465         {
1466             buffer[i] = 0;
1467             return EINTR;
1468         }
1469         if (n == 0)
1470         {
1471             buffer[i] = 0;
1472             return 0;
1473         }
1474         if (buffer[i] == '\n')
1475         {
1476             buffer[i] = 0;
1477             return 1;
1478         }
1479     }
1480     buffer[size - 1] = 0;
1481     return 0;
1482 }
1483 #endif /* ENABLE_VFS_NET */
1484
1485 /* --------------------------------------------------------------------------------------------- */