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