lib/vfs/direntry.c

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