lib/vfs/direntry.c

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