src/vfs/extfs/extfs.c

   1 /*
   2    Virtual File System: External file system.
   3
   4    Copyright (C) 1995-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Jakub Jelinek, 1995
   9    Pavel Machek, 1998
  10    Andrew T. Veliath, 1999
  11    Slava Zanko <slavazanko@gmail.com>, 2013
  12
  13    This file is part of the Midnight Commander.
  14
  15    The Midnight Commander is free software: you can redistribute it
  16    and/or modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation, either version 3 of the License,
  18    or (at your option) any later version.
  19
  20    The Midnight Commander is distributed in the hope that it will be useful,
  21    but WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23    GNU General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /**
  30  * \file
  31  * \brief Source: Virtual File System: External file system
  32  * \author Jakub Jelinek
  33  * \author Pavel Machek
  34  * \author Andrew T. Veliath
  35  * \date 1995, 1998, 1999
  36  */
  37
  38 /* Namespace: init_extfs */
  39
  40 #include <config.h>
  41
  42 #include <stdio.h>
  43 #include <ctype.h>
  44 #include <string.h>
  45 #include <stdlib.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <unistd.h>
  49 #include <signal.h>
  50 #include <errno.h>
  51 #include <sys/wait.h>
  52
  53 #include "lib/global.h"
  54 #include "lib/fileloc.h"
  55 #include "lib/mcconfig.h"
  56 #include "lib/util.h"
  57 #include "lib/widget.h"         /* message() */
  58
  59 #include "src/execute.h"        /* For shell_execute */
  60
  61 #include "lib/vfs/vfs.h"
  62 #include "lib/vfs/utilvfs.h"
  63 #include "lib/vfs/xdirentry.h"
  64 #include "lib/vfs/gc.h"         /* vfs_rmstamp */
  65
  66 #include "extfs.h"
  67
  68 /*** global variables ****************************************************************************/
  69
  70 /*** file scope macro definitions ****************************************************************/
  71
  72 #undef ERRNOR
  73 #define ERRNOR(x,y) do { my_errno = x; return y; } while(0)
  74
  75 #define RECORDSIZE 512
  76
  77 #define EXTFS_SUPER(a) ((struct extfs_super_t *) (a))
  78
  79 /*** file scope type declarations ****************************************************************/
  80
  81 struct extfs_super_t
  82 {
  83     struct vfs_s_super base;    /* base class */
  84
  85     int fstype;
  86     char *local_name;
  87     struct stat local_stat;
  88     dev_t rdev;
  89 };
  90
  91 typedef struct
  92 {
  93     char *path;
  94     char *prefix;
  95     gboolean need_archive;
  96 } extfs_plugin_info_t;
  97
  98 /*** forward declarations (file scope functions) *************************************************/
  99
 100 static struct vfs_s_entry *extfs_resolve_symlinks_int (struct vfs_s_entry *entry, GSList * list);
 101
 102 /*** file scope variables ************************************************************************/
 103
 104 static GArray *extfs_plugins = NULL;
 105
 106 static gboolean errloop;
 107 static gboolean notadir;
 108
 109 static struct vfs_s_subclass extfs_subclass;
 110 static struct vfs_class *vfs_extfs_ops = VFS_CLASS (&extfs_subclass);
 111
 112 static int my_errno = 0;
 113
 114 /* --------------------------------------------------------------------------------------------- */
 115 /*** file scope functions ************************************************************************/
 116 /* --------------------------------------------------------------------------------------------- */
 117
 118 static struct extfs_super_t *
 119 extfs_super_new (struct vfs_class *me, const char *name, const vfs_path_t *local_name_vpath,
 120                  int fstype)
 121 {
 122     struct extfs_super_t *super;
 123     struct vfs_s_super *vsuper;
 124
 125     super = g_new0 (struct extfs_super_t, 1);
 126     vsuper = VFS_SUPER (super);
 127
 128     vsuper->me = me;
 129     vsuper->name = g_strdup (name);
 130
 131     super->fstype = fstype;
 132
 133     if (local_name_vpath != NULL)
 134     {
 135         super->local_name = g_strdup (vfs_path_get_last_path_str (local_name_vpath));
 136         mc_stat (local_name_vpath, &super->local_stat);
 137     }
 138
 139     VFS_SUBCLASS (me)->supers = g_list_prepend (VFS_SUBCLASS (me)->supers, super);
 140
 141     return super;
 142 }
 143
 144 /* --------------------------------------------------------------------------------------------- */
 145
 146 /* unlike vfs_s_new_entry(), inode->ent is kept */
 147 static struct vfs_s_entry *
 148 extfs_entry_new (struct vfs_class *me, const char *name, struct vfs_s_inode *inode)
 149 {
 150     struct vfs_s_entry *entry;
 151
 152     (void) me;
 153
 154     entry = g_new0 (struct vfs_s_entry, 1);
 155
 156     entry->name = g_strdup (name);
 157     entry->ino = inode;
 158
 159     return entry;
 160 }
 161
 162 /* --------------------------------------------------------------------------------------------- */
 163
 164 static void
 165 extfs_fill_name (void *data, void *user_data)
 166 {
 167     struct vfs_s_super *a = VFS_SUPER (data);
 168     fill_names_f func = (fill_names_f) user_data;
 169     extfs_plugin_info_t *info;
 170     char *name;
 171
 172     info = &g_array_index (extfs_plugins, extfs_plugin_info_t, EXTFS_SUPER (a)->fstype);
 173     name =
 174         g_strconcat (a->name != NULL ? a->name : "", PATH_SEP_STR, info->prefix,
 175                      VFS_PATH_URL_DELIMITER, (char *) NULL);
 176     func (name);
 177     g_free (name);
 178 }
 179
 180 /* --------------------------------------------------------------------------------------------- */
 181
 182 static gint
 183 extfs_cmp_archive (const void *a, const void *b)
 184 {
 185     const struct vfs_s_super *ar = (const struct vfs_s_super *) a;
 186     const char *archive_name = (const char *) b;
 187
 188     return (ar->name != NULL && strcmp (ar->name, archive_name) == 0) ? 0 : 1;
 189 }
 190
 191 /* --------------------------------------------------------------------------------------------- */
 192
 193 static struct vfs_s_entry *
 194 extfs_generate_entry (struct extfs_super_t *archive, const char *name, struct vfs_s_inode *parent,
 195                       mode_t mode)
 196 {
 197     struct vfs_class *me = VFS_SUPER (archive)->me;
 198     struct stat st;
 199     mode_t myumask;
 200     struct vfs_s_inode *inode;
 201     struct vfs_s_entry *entry;
 202
 203     memset (&st, 0, sizeof (st));
 204     st.st_ino = VFS_SUPER (archive)->ino_usage++;
 205     st.st_dev = archive->rdev;
 206     myumask = umask (022);
 207     umask (myumask);
 208     st.st_mode = mode & ~myumask;
 209     st.st_uid = getuid ();
 210     st.st_gid = getgid ();
 211     st.st_mtime = time (NULL);
 212     st.st_atime = st.st_mtime;
 213     st.st_ctime = st.st_mtime;
 214     st.st_nlink = 1;
 215
 216     inode = vfs_s_new_inode (me, VFS_SUPER (archive), &st);
 217     entry = vfs_s_new_entry (me, name, inode);
 218     if (parent != NULL)
 219         vfs_s_insert_entry (me, parent, entry);
 220
 221     return entry;
 222 }
 223
 224 /* --------------------------------------------------------------------------------------------- */
 225
 226 static struct vfs_s_entry *
 227 extfs_find_entry_int (struct vfs_s_inode *dir, const char *name, GSList *list, int flags)
 228 {
 229     struct vfs_s_entry *pent, *pdir;
 230     const char *p, *name_end;
 231     char *q;
 232     char c = PATH_SEP;
 233     struct extfs_super_t *super;
 234
 235     if (g_path_is_absolute (name))
 236     {
 237         /* Handle absolute paths */
 238         name = g_path_skip_root (name);
 239         dir = dir->super->root;
 240     }
 241
 242     super = EXTFS_SUPER (dir->super);
 243     pent = dir->ent;
 244     p = name;
 245     name_end = name + strlen (name);
 246
 247     while ((pent != NULL) && (c != '\0') && (*p != '\0'))
 248     {
 249         q = strchr (p, PATH_SEP);
 250         if (q == NULL)
 251             q = (char *) name_end;
 252
 253         c = *q;
 254         *q = '\0';
 255
 256         if (DIR_IS_DOTDOT (p))
 257             pent = pent->dir != NULL ? pent->dir->ent : NULL;
 258         else
 259         {
 260             GList *pl;
 261
 262             pent = extfs_resolve_symlinks_int (pent, list);
 263             if (pent == NULL)
 264             {
 265                 *q = c;
 266                 return NULL;
 267             }
 268
 269             if (!S_ISDIR (pent->ino->st.st_mode))
 270             {
 271                 *q = c;
 272                 notadir = TRUE;
 273                 return NULL;
 274             }
 275
 276             pdir = pent;
 277             pl = g_queue_find_custom (pent->ino->subdir, p, vfs_s_entry_compare);
 278             pent = pl != NULL ? VFS_ENTRY (pl->data) : NULL;
 279             if (pent != NULL && q + 1 > name_end)
 280             {
 281                 /* Hack: I keep the original semanthic unless q+1 would break in the strchr */
 282                 *q = c;
 283                 notadir = !S_ISDIR (pent->ino->st.st_mode);
 284                 return pent;
 285             }
 286
 287             /* When we load archive, we create automagically non-existent directories */
 288             if (pent == NULL && (flags & FL_MKDIR) != 0)
 289                 pent = extfs_generate_entry (super, p, pdir->ino, S_IFDIR | 0777);
 290             if (pent == NULL && (flags & FL_MKFILE) != 0)
 291                 pent = extfs_generate_entry (super, p, pdir->ino, S_IFREG | 0666);
 292         }
 293
 294         /* Next iteration */
 295         *q = c;
 296         if (c != '\0')
 297             p = q + 1;
 298     }
 299     if (pent == NULL)
 300         my_errno = ENOENT;
 301     return pent;
 302 }
 303
 304 /* --------------------------------------------------------------------------------------------- */
 305
 306 static struct vfs_s_entry *
 307 extfs_find_entry (struct vfs_s_inode *dir, const char *name, int flags)
 308 {
 309     struct vfs_s_entry *res;
 310
 311     errloop = FALSE;
 312     notadir = FALSE;
 313
 314     res = extfs_find_entry_int (dir, name, NULL, flags);
 315     if (res == NULL)
 316     {
 317         if (errloop)
 318             my_errno = ELOOP;
 319         else if (notadir)
 320             my_errno = ENOTDIR;
 321     }
 322     return res;
 323 }
 324
 325 /* --------------------------------------------------------------------------------------------- */
 326
 327 static void
 328 extfs_fill_names (struct vfs_class *me, fill_names_f func)
 329 {
 330     g_list_foreach (VFS_SUBCLASS (me)->supers, extfs_fill_name, func);
 331 }
 332
 333 /* --------------------------------------------------------------------------------------------- */
 334
 335 /* Create this function because VFSF_USETMP flag is not used in extfs */
 336 static void
 337 extfs_free_inode (struct vfs_class *me, struct vfs_s_inode *ino)
 338 {
 339     (void) me;
 340
 341     if (ino->localname != NULL)
 342     {
 343         unlink (ino->localname);
 344         MC_PTR_FREE (ino->localname);
 345     }
 346 }
 347
 348 /* --------------------------------------------------------------------------------------------- */
 349
 350 static void
 351 extfs_free_archive (struct vfs_class *me, struct vfs_s_super *psup)
 352 {
 353     struct extfs_super_t *archive = EXTFS_SUPER (psup);
 354
 355     (void) me;
 356
 357     if (archive->local_name != NULL)
 358     {
 359         struct stat my;
 360         vfs_path_t *local_name_vpath, *name_vpath;
 361
 362         local_name_vpath = vfs_path_from_str (archive->local_name);
 363         name_vpath = vfs_path_from_str (psup->name);
 364         mc_stat (local_name_vpath, &my);
 365         mc_ungetlocalcopy (name_vpath, local_name_vpath,
 366                            archive->local_stat.st_mtime != my.st_mtime);
 367         vfs_path_free (local_name_vpath, TRUE);
 368         vfs_path_free (name_vpath, TRUE);
 369         g_free (archive->local_name);
 370     }
 371 }
 372
 373 /* --------------------------------------------------------------------------------------------- */
 374
 375 static inline char *
 376 extfs_skip_leading_dotslash (char *s)
 377 {
 378     /* Skip leading "./" (if present).
 379      * Some programs don't understand it:
 380      *
 381      * $ zip file.zip ./-file2.txt file1.txt
 382      *   adding: -file2.txt (stored 0%)
 383      *   adding: file1.txt (stored 0%)
 384      * $ /usr/lib/mc/extfs.d/uzip copyout file.zip ./-file2.txt ./tmp-file2.txt
 385      * caution: filename not matched:  ./-file2.txt
 386      */
 387     if (s[0] == '.' && s[1] == PATH_SEP)
 388         s += 2;
 389
 390     return s;
 391 }
 392
 393 /* --------------------------------------------------------------------------------------------- */
 394
 395 static int
 396 extfs_add_file (struct extfs_super_t *archive, const char *file_name)
 397 {
 398     struct vfs_s_super *super = VFS_SUPER (archive);
 399     struct stat hstat;
 400     char *current_file_name = NULL, *current_link_name = NULL;
 401     int ret = 0;
 402
 403     if (vfs_parse_ls_lga (file_name, &hstat, &current_file_name, &current_link_name, NULL))
 404     {
 405         char *cfn = current_file_name;
 406
 407         if (*cfn != '\0')
 408         {
 409             struct vfs_s_entry *entry;
 410             struct vfs_s_entry *pent = NULL;
 411             struct vfs_s_inode *inode;
 412             char *p, *q;
 413
 414             cfn = extfs_skip_leading_dotslash (cfn);
 415             if (IS_PATH_SEP (*cfn))
 416                 cfn++;
 417             p = strchr (cfn, '\0');
 418             if (p != cfn && IS_PATH_SEP (p[-1]))
 419                 p[-1] = '\0';
 420             p = strrchr (cfn, PATH_SEP);
 421             if (p == NULL)
 422             {
 423                 p = cfn;
 424                 q = strchr (cfn, '\0');
 425             }
 426             else
 427             {
 428                 *(p++) = '\0';
 429                 q = cfn;
 430             }
 431
 432             if (*q != '\0')
 433             {
 434                 pent = extfs_find_entry (super->root, q, FL_MKDIR);
 435                 if (pent == NULL)
 436                 {
 437                     ret = -1;
 438                     goto done;
 439                 }
 440             }
 441
 442             if (pent != NULL)
 443             {
 444                 entry = extfs_entry_new (super->me, p, pent->ino);
 445                 entry->dir = pent->ino;
 446                 g_queue_push_tail (pent->ino->subdir, entry);
 447             }
 448             else
 449             {
 450                 entry = extfs_entry_new (super->me, p, super->root);
 451                 entry->dir = super->root;
 452                 g_queue_push_tail (super->root->subdir, entry);
 453             }
 454
 455             if (!S_ISLNK (hstat.st_mode) && (current_link_name != NULL))
 456             {
 457                 pent = extfs_find_entry (super->root, current_link_name, FL_NONE);
 458                 if (pent == NULL)
 459                 {
 460                     ret = -1;
 461                     goto done;
 462                 }
 463
 464                 pent->ino->st.st_nlink++;
 465                 entry->ino = pent->ino;
 466             }
 467             else
 468             {
 469                 struct stat st;
 470
 471                 memset (&st, 0, sizeof (st));
 472                 st.st_ino = super->ino_usage++;
 473                 st.st_nlink = 1;
 474                 st.st_dev = archive->rdev;
 475                 st.st_mode = hstat.st_mode;
 476 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 477                 st.st_rdev = hstat.st_rdev;
 478 #endif
 479                 st.st_uid = hstat.st_uid;
 480                 st.st_gid = hstat.st_gid;
 481                 st.st_size = hstat.st_size;
 482                 st.st_mtime = hstat.st_mtime;
 483                 st.st_atime = hstat.st_atime;
 484                 st.st_ctime = hstat.st_ctime;
 485
 486                 if (current_link_name == NULL && S_ISLNK (hstat.st_mode))
 487                     st.st_mode &= ~S_IFLNK;     /* You *DON'T* want to do this always */
 488
 489                 inode = vfs_s_new_inode (super->me, super, &st);
 490                 inode->ent = entry;
 491                 entry->ino = inode;
 492
 493                 if (current_link_name != NULL && S_ISLNK (hstat.st_mode))
 494                 {
 495                     inode->linkname = current_link_name;
 496                     current_link_name = NULL;
 497                 }
 498             }
 499         }
 500
 501       done:
 502         g_free (current_file_name);
 503         g_free (current_link_name);
 504     }
 505
 506     return ret;
 507 }
 508
 509 /* --------------------------------------------------------------------------------------------- */
 510
 511 static mc_pipe_t *
 512 extfs_open_archive (int fstype, const char *name, struct extfs_super_t **pparc, GError **error)
 513 {
 514     const extfs_plugin_info_t *info;
 515     static dev_t archive_counter = 0;
 516     mc_pipe_t *result = NULL;
 517     mode_t mode;
 518     char *cmd;
 519     struct stat mystat;
 520     struct extfs_super_t *current_archive;
 521     struct vfs_s_entry *root_entry;
 522     char *tmp = NULL;
 523     vfs_path_t *local_name_vpath = NULL;
 524     vfs_path_t *name_vpath;
 525
 526     memset (&mystat, 0, sizeof (mystat));
 527
 528     name_vpath = vfs_path_from_str (name);
 529     info = &g_array_index (extfs_plugins, extfs_plugin_info_t, fstype);
 530
 531     if (info->need_archive)
 532     {
 533         if (mc_stat (name_vpath, &mystat) == -1)
 534         {
 535             mc_propagate_error (error, 0, "%s", unix_error_string (errno));
 536             goto ret;
 537         }
 538
 539         if (!vfs_file_is_local (name_vpath))
 540         {
 541             local_name_vpath = mc_getlocalcopy (name_vpath);
 542             if (local_name_vpath == NULL)
 543                 goto ret;
 544         }
 545
 546         tmp = name_quote (vfs_path_get_last_path_str (name_vpath), FALSE);
 547     }
 548
 549     cmd = g_strconcat (info->path, info->prefix, " list ",
 550                        vfs_path_get_last_path_str (local_name_vpath) != NULL ?
 551                        vfs_path_get_last_path_str (local_name_vpath) : tmp, (char *) NULL);
 552     g_free (tmp);
 553
 554     result = mc_popen (cmd, TRUE, TRUE, error);
 555     g_free (cmd);
 556
 557     if (result == NULL)
 558     {
 559         if (local_name_vpath != NULL)
 560         {
 561             mc_ungetlocalcopy (name_vpath, local_name_vpath, FALSE);
 562             vfs_path_free (local_name_vpath, TRUE);
 563         }
 564         goto ret;
 565     }
 566
 567     current_archive = extfs_super_new (vfs_extfs_ops, name, local_name_vpath, fstype);
 568     current_archive->rdev = archive_counter++;
 569     vfs_path_free (local_name_vpath, TRUE);
 570
 571     mode = mystat.st_mode & 07777;
 572     if (mode & 0400)
 573         mode |= 0100;
 574     if (mode & 0040)
 575         mode |= 0010;
 576     if (mode & 0004)
 577         mode |= 0001;
 578     mode |= S_IFDIR;
 579
 580     root_entry = extfs_generate_entry (current_archive, PATH_SEP_STR, NULL, mode);
 581     root_entry->ino->st.st_uid = mystat.st_uid;
 582     root_entry->ino->st.st_gid = mystat.st_gid;
 583     root_entry->ino->st.st_atime = mystat.st_atime;
 584     root_entry->ino->st.st_ctime = mystat.st_ctime;
 585     root_entry->ino->st.st_mtime = mystat.st_mtime;
 586     root_entry->ino->ent = root_entry;
 587     VFS_SUPER (current_archive)->root = root_entry->ino;
 588
 589     *pparc = current_archive;
 590
 591   ret:
 592     vfs_path_free (name_vpath, TRUE);
 593     return result;
 594 }
 595
 596 /* --------------------------------------------------------------------------------------------- */
 597 /**
 598  * Main loop for reading an archive.
 599  * Return 0 on success, -1 on error.
 600  */
 601
 602 static int
 603 extfs_read_archive (mc_pipe_t *pip, struct extfs_super_t *archive, GError **error)
 604 {
 605     int ret = 0;
 606     GString *buffer;
 607     GString *err_msg = NULL;
 608     GString *remain_file_name = NULL;
 609
 610     while (ret != -1)
 611     {
 612         /* init buffers before call of mc_pread() */
 613         pip->out.len = MC_PIPE_BUFSIZE;
 614         pip->err.len = MC_PIPE_BUFSIZE;
 615
 616         mc_pread (pip, error);
 617
 618         if (*error != NULL)
 619             return (-1);
 620
 621         if (pip->err.len > 0)
 622         {
 623             /* join errors/warnings */
 624             if (err_msg == NULL)
 625                 err_msg = g_string_new_len (pip->err.buf, pip->err.len);
 626             else
 627             {
 628                 if (err_msg->str[err_msg->len - 1] != '\n')
 629                     g_string_append_c (err_msg, '\n');
 630                 g_string_append_len (err_msg, pip->err.buf, pip->err.len);
 631             }
 632         }
 633
 634         if (pip->out.len == MC_PIPE_STREAM_EOF)
 635             break;
 636
 637         if (pip->out.len == 0)
 638             continue;
 639
 640         if (pip->out.len == MC_PIPE_ERROR_READ)
 641             return (-1);
 642
 643         while (ret != -1 && (buffer = mc_pstream_get_string (&pip->out)) != NULL)
 644         {
 645             /* handle a \n-separated file list */
 646
 647             if (buffer->str[buffer->len - 1] == '\n')
 648             {
 649                 /* entire file name or last chunk */
 650
 651                 g_string_truncate (buffer, buffer->len - 1);
 652
 653                 /* join filename chunks */
 654                 if (remain_file_name != NULL)
 655                 {
 656                     g_string_append_len (remain_file_name, buffer->str, buffer->len);
 657                     g_string_free (buffer, TRUE);
 658                     buffer = remain_file_name;
 659                     remain_file_name = NULL;
 660                 }
 661             }
 662             else
 663             {
 664                 /* first or middle chunk of file name */
 665
 666                 if (remain_file_name == NULL)
 667                     remain_file_name = buffer;
 668                 else
 669                 {
 670                     g_string_append_len (remain_file_name, buffer->str, buffer->len);
 671                     g_string_free (buffer, TRUE);
 672                 }
 673
 674                 continue;
 675             }
 676
 677             ret = extfs_add_file (archive, buffer->str);
 678
 679             g_string_free (buffer, TRUE);
 680         }
 681     }
 682
 683     if (remain_file_name != NULL)
 684         g_string_free (remain_file_name, TRUE);
 685
 686     if (err_msg != NULL)
 687     {
 688         if (*error == NULL)
 689             mc_propagate_error (error, 0, "%s", err_msg->str);
 690
 691         g_string_free (err_msg, TRUE);
 692     }
 693     else if (ret == -1)
 694         mc_propagate_error (error, 0, "%s", _("Inconsistent archive"));
 695
 696     return ret;
 697 }
 698
 699 /* --------------------------------------------------------------------------------------------- */
 700
 701 static int
 702 extfs_which (struct vfs_class *me, const char *path)
 703 {
 704     size_t path_len;
 705     size_t i;
 706
 707     (void) me;
 708
 709     path_len = strlen (path);
 710
 711     for (i = 0; i < extfs_plugins->len; i++)
 712     {
 713         extfs_plugin_info_t *info;
 714
 715         info = &g_array_index (extfs_plugins, extfs_plugin_info_t, i);
 716
 717         if ((strncmp (path, info->prefix, path_len) == 0)
 718             && ((info->prefix[path_len] == '\0') || (info->prefix[path_len] == '+')))
 719             return i;
 720     }
 721     return -1;
 722 }
 723
 724 /* --------------------------------------------------------------------------------------------- */
 725
 726 static int
 727 extfs_open_and_read_archive (int fstype, const char *name, struct extfs_super_t **archive)
 728 {
 729     int result = -1;
 730     struct extfs_super_t *a;
 731     mc_pipe_t *pip;
 732     GError *error = NULL;
 733
 734     pip = extfs_open_archive (fstype, name, archive, &error);
 735
 736     a = *archive;
 737
 738     if (pip == NULL)
 739     {
 740         const extfs_plugin_info_t *info;
 741
 742         info = &g_array_index (extfs_plugins, extfs_plugin_info_t, fstype);
 743         if (error == NULL)
 744             message (D_ERROR, MSG_ERROR, _("Cannot open %s archive\n%s"), info->prefix, name);
 745         else
 746         {
 747             message (D_ERROR, MSG_ERROR, _("Cannot open %s archive\n%s:\n%s"), info->prefix, name,
 748                      error->message);
 749             g_error_free (error);
 750         }
 751     }
 752     else
 753     {
 754         result = extfs_read_archive (pip, a, &error);
 755
 756         if (result != 0)
 757             VFS_SUPER (a)->me->free (VFS_SUPER (a));
 758
 759         if (error != NULL)
 760         {
 761             message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\n%s"), error->message);
 762             g_error_free (error);
 763         }
 764
 765         mc_pclose (pip, NULL);
 766     }
 767
 768     return result;
 769 }
 770
 771 /* --------------------------------------------------------------------------------------------- */
 772 /**
 773  * Dissect the path and create corresponding superblock.
 774  */
 775 static const char *
 776 extfs_get_path (const vfs_path_t *vpath, struct extfs_super_t **archive, int flags)
 777 {
 778     char *archive_name;
 779     int result = -1;
 780     GList *parc;
 781     int fstype;
 782     const vfs_path_element_t *path_element;
 783     struct extfs_super_t *a = NULL;
 784
 785     path_element = vfs_path_get_by_index (vpath, -1);
 786
 787     fstype = extfs_which (path_element->class, path_element->vfs_prefix);
 788     if (fstype == -1)
 789         return NULL;
 790
 791     archive_name = vfs_path_to_str_elements_count (vpath, -1);
 792
 793     /* All filesystems should have some local archive, at least it can be PATH_SEP ('/'). */
 794     parc = g_list_find_custom (extfs_subclass.supers, archive_name, extfs_cmp_archive);
 795     if (parc != NULL)
 796     {
 797         a = EXTFS_SUPER (parc->data);
 798         vfs_stamp (vfs_extfs_ops, (vfsid) a);
 799         g_free (archive_name);
 800     }
 801     else
 802     {
 803         if ((flags & FL_NO_OPEN) == 0)
 804             result = extfs_open_and_read_archive (fstype, archive_name, &a);
 805
 806         g_free (archive_name);
 807
 808         if (result == -1)
 809         {
 810             path_element->class->verrno = EIO;
 811             return NULL;
 812         }
 813     }
 814
 815     *archive = a;
 816     return path_element->path;
 817 }
 818
 819 /* --------------------------------------------------------------------------------------------- */
 820 /* Return allocated path (without leading slash) inside the archive  */
 821
 822 static char *
 823 extfs_get_path_from_entry (const struct vfs_s_entry *entry)
 824 {
 825     const struct vfs_s_entry *e;
 826     GString *localpath;
 827
 828     localpath = g_string_new ("");
 829
 830     for (e = entry; e->dir != NULL; e = e->dir->ent)
 831     {
 832         g_string_prepend (localpath, e->name);
 833         if (e->dir->ent->dir != NULL)
 834             g_string_prepend_c (localpath, PATH_SEP);
 835     }
 836
 837     return g_string_free (localpath, FALSE);
 838 }
 839
 840 /* --------------------------------------------------------------------------------------------- */
 841
 842 static struct vfs_s_entry *
 843 extfs_resolve_symlinks_int (struct vfs_s_entry *entry, GSList *list)
 844 {
 845     struct vfs_s_entry *pent = NULL;
 846
 847     if (!S_ISLNK (entry->ino->st.st_mode))
 848         return entry;
 849
 850     if (g_slist_find (list, entry) != NULL)
 851     {
 852         /* Here we protect us against symlink looping */
 853         errloop = TRUE;
 854     }
 855     else
 856     {
 857         GSList *looping;
 858
 859         looping = g_slist_prepend (list, entry);
 860         pent = extfs_find_entry_int (entry->dir, entry->ino->linkname, looping, FL_NONE);
 861         looping = g_slist_delete_link (looping, looping);
 862
 863         if (pent == NULL)
 864             my_errno = ENOENT;
 865     }
 866
 867     return pent;
 868 }
 869
 870 /* --------------------------------------------------------------------------------------------- */
 871
 872 static struct vfs_s_entry *
 873 extfs_resolve_symlinks (struct vfs_s_entry *entry)
 874 {
 875     struct vfs_s_entry *res;
 876
 877     errloop = FALSE;
 878     notadir = FALSE;
 879     res = extfs_resolve_symlinks_int (entry, NULL);
 880     if (res == NULL)
 881     {
 882         if (errloop)
 883             my_errno = ELOOP;
 884         else if (notadir)
 885             my_errno = ENOTDIR;
 886     }
 887     return res;
 888 }
 889
 890 /* --------------------------------------------------------------------------------------------- */
 891
 892 static char *
 893 extfs_get_archive_name (const struct extfs_super_t *archive)
 894 {
 895     const char *archive_name;
 896
 897     if (archive->local_name != NULL)
 898         archive_name = archive->local_name;
 899     else
 900         archive_name = CONST_VFS_SUPER (archive)->name;
 901
 902     if (archive_name == NULL || *archive_name == '\0')
 903         return g_strdup ("no_archive_name");
 904     else
 905     {
 906         char *ret_str;
 907         vfs_path_t *vpath;
 908         const char *path;
 909
 910         vpath = vfs_path_from_str (archive_name);
 911         path = vfs_path_get_last_path_str (vpath);
 912         ret_str = g_strdup (path);
 913         vfs_path_free (vpath, TRUE);
 914         return ret_str;
 915     }
 916 }
 917
 918 /* --------------------------------------------------------------------------------------------- */
 919 /** Don't pass localname as NULL */
 920
 921 static int
 922 extfs_cmd (const char *str_extfs_cmd, const struct extfs_super_t *archive,
 923            const struct vfs_s_entry *entry, const char *localname)
 924 {
 925     char *file;
 926     char *quoted_file;
 927     char *archive_name, *quoted_archive_name;
 928     const extfs_plugin_info_t *info;
 929     char *cmd = NULL;
 930     int retval = 0;
 931     GError *error = NULL;
 932     mc_pipe_t *pip;
 933
 934     file = extfs_get_path_from_entry (entry);
 935     quoted_file = name_quote (file, FALSE);
 936     g_free (file);
 937
 938     if (quoted_file == NULL)
 939     {
 940         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\nwrong file name"));
 941         return (-1);
 942     }
 943
 944     /* Skip leading "./" (if present) added in name_quote() */
 945     file = extfs_skip_leading_dotslash (quoted_file);
 946
 947     archive_name = extfs_get_archive_name (archive);
 948     quoted_archive_name = name_quote (archive_name, FALSE);
 949     g_free (archive_name);
 950
 951     if (quoted_archive_name == NULL)
 952     {
 953         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\nwrong archive name"));
 954         return (-1);
 955     }
 956
 957     info = &g_array_index (extfs_plugins, extfs_plugin_info_t, archive->fstype);
 958
 959     if (localname == NULL || *localname == '\0')
 960         cmd = g_strconcat (info->path, info->prefix, str_extfs_cmd, quoted_archive_name, " ",
 961                            file, (char *) NULL);
 962     else
 963     {
 964         char *quoted_localname;
 965
 966         quoted_localname = name_quote (localname, FALSE);
 967         cmd = g_strconcat (info->path, info->prefix, str_extfs_cmd, quoted_archive_name, " ",
 968                            file, " ", quoted_localname, (char *) NULL);
 969         g_free (quoted_localname);
 970     }
 971
 972     g_free (quoted_file);
 973     g_free (quoted_archive_name);
 974
 975     if (cmd == NULL)
 976     {
 977         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\ncannot build command"));
 978         return (-1);
 979     }
 980
 981     /* don't read stdout */
 982     pip = mc_popen (cmd, FALSE, TRUE, &error);
 983     g_free (cmd);
 984
 985     if (pip == NULL)
 986     {
 987         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\n%s"), error->message);
 988         g_error_free (error);
 989         return (-1);
 990     }
 991
 992     pip->err.null_term = TRUE;
 993
 994     mc_pread (pip, &error);
 995     if (error != NULL)
 996     {
 997         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\n%s"), error->message);
 998         g_error_free (error);
 999         retval = -1;
1000     }
1001     else if (pip->err.len > 0)
1002         message (D_ERROR, MSG_ERROR, _("EXTFS virtual file system:\n%s"), pip->err.buf);
1003
1004     mc_pclose (pip, NULL);
1005
1006     return retval;
1007 }
1008
1009 /* --------------------------------------------------------------------------------------------- */
1010
1011 static void
1012 extfs_run (const vfs_path_t *vpath)
1013 {
1014     struct extfs_super_t *archive = NULL;
1015     const char *p;
1016     char *q, *archive_name, *quoted_archive_name;
1017     char *cmd;
1018     const extfs_plugin_info_t *info;
1019
1020     p = extfs_get_path (vpath, &archive, FL_NONE);
1021     if (p == NULL)
1022         return;
1023     q = name_quote (p, FALSE);
1024
1025     archive_name = extfs_get_archive_name (archive);
1026     quoted_archive_name = name_quote (archive_name, FALSE);
1027     g_free (archive_name);
1028     info = &g_array_index (extfs_plugins, extfs_plugin_info_t, archive->fstype);
1029     cmd =
1030         g_strconcat (info->path, info->prefix, " run ", quoted_archive_name, " ", q, (char *) NULL);
1031     g_free (quoted_archive_name);
1032     g_free (q);
1033     shell_execute (cmd, 0);
1034     g_free (cmd);
1035 }
1036
1037 /* --------------------------------------------------------------------------------------------- */
1038
1039 static void *
1040 extfs_open (const vfs_path_t *vpath, int flags, mode_t mode)
1041 {
1042     vfs_file_handler_t *extfs_info;
1043     struct extfs_super_t *archive = NULL;
1044     const char *q;
1045     struct vfs_s_entry *entry;
1046     int local_handle;
1047     gboolean created = FALSE;
1048
1049     q = extfs_get_path (vpath, &archive, FL_NONE);
1050     if (q == NULL)
1051         return NULL;
1052     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1053     if ((entry == NULL) && ((flags & O_CREAT) != 0))
1054     {
1055         /* Create new entry */
1056         entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_MKFILE);
1057         created = (entry != NULL);
1058     }
1059
1060     if (entry == NULL)
1061         return NULL;
1062     entry = extfs_resolve_symlinks (entry);
1063     if (entry == NULL)
1064         return NULL;
1065
1066     if (S_ISDIR (entry->ino->st.st_mode))
1067         ERRNOR (EISDIR, NULL);
1068
1069     if (entry->ino->localname == NULL)
1070     {
1071         vfs_path_t *local_filename_vpath;
1072         const char *local_filename;
1073
1074         local_handle = vfs_mkstemps (&local_filename_vpath, "extfs", entry->name);
1075
1076         if (local_handle == -1)
1077             return NULL;
1078         close (local_handle);
1079         local_filename = vfs_path_get_last_path_str (local_filename_vpath);
1080
1081         if (!created && ((flags & O_TRUNC) == 0)
1082             && extfs_cmd (" copyout ", archive, entry, local_filename))
1083         {
1084             unlink (local_filename);
1085             vfs_path_free (local_filename_vpath, TRUE);
1086             my_errno = EIO;
1087             return NULL;
1088         }
1089         entry->ino->localname = g_strdup (local_filename);
1090         vfs_path_free (local_filename_vpath, TRUE);
1091     }
1092
1093     local_handle = open (entry->ino->localname, NO_LINEAR (flags), mode);
1094
1095     if (local_handle == -1)
1096     {
1097         /* file exists(may be). Need to drop O_CREAT flag and truncate file content */
1098         flags = ~O_CREAT & (NO_LINEAR (flags) | O_TRUNC);
1099         local_handle = open (entry->ino->localname, flags, mode);
1100     }
1101
1102     if (local_handle == -1)
1103         ERRNOR (EIO, NULL);
1104
1105     extfs_info = g_new (vfs_file_handler_t, 1);
1106     vfs_s_init_fh (extfs_info, entry->ino, created);
1107     extfs_info->handle = local_handle;
1108
1109     /* i.e. we had no open files and now we have one */
1110     vfs_rmstamp (vfs_extfs_ops, (vfsid) archive);
1111     VFS_SUPER (archive)->fd_usage++;
1112     return extfs_info;
1113 }
1114
1115 /* --------------------------------------------------------------------------------------------- */
1116
1117 static ssize_t
1118 extfs_read (void *fh, char *buffer, size_t count)
1119 {
1120     vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
1121
1122     return read (file->handle, buffer, count);
1123 }
1124
1125 /* --------------------------------------------------------------------------------------------- */
1126
1127 static int
1128 extfs_close (void *fh)
1129 {
1130     vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
1131     int errno_code = 0;
1132
1133     close (file->handle);
1134     file->handle = -1;
1135
1136     /* Commit the file if it has changed */
1137     if (file->changed)
1138     {
1139         struct stat file_status;
1140
1141         if (extfs_cmd
1142             (" copyin ", EXTFS_SUPER (VFS_FILE_HANDLER_SUPER (fh)), file->ino->ent,
1143              file->ino->localname))
1144             errno_code = EIO;
1145
1146         if (stat (file->ino->localname, &file_status) != 0)
1147             errno_code = EIO;
1148         else
1149             file->ino->st.st_size = file_status.st_size;
1150
1151         file->ino->st.st_mtime = time (NULL);
1152     }
1153
1154     if (--VFS_FILE_HANDLER_SUPER (fh)->fd_usage == 0)
1155         vfs_stamp_create (vfs_extfs_ops, VFS_FILE_HANDLER_SUPER (fh));
1156
1157     g_free (fh);
1158     if (errno_code != 0)
1159         ERRNOR (EIO, -1);
1160     return 0;
1161 }
1162
1163 /* --------------------------------------------------------------------------------------------- */
1164
1165 static int
1166 extfs_errno (struct vfs_class *me)
1167 {
1168     (void) me;
1169     return my_errno;
1170 }
1171
1172 /* --------------------------------------------------------------------------------------------- */
1173
1174 static void *
1175 extfs_opendir (const vfs_path_t *vpath)
1176 {
1177     struct extfs_super_t *archive = NULL;
1178     const char *q;
1179     struct vfs_s_entry *entry;
1180     GList **info;
1181
1182     q = extfs_get_path (vpath, &archive, FL_NONE);
1183     if (q == NULL)
1184         return NULL;
1185     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1186     if (entry == NULL)
1187         return NULL;
1188     entry = extfs_resolve_symlinks (entry);
1189     if (entry == NULL)
1190         return NULL;
1191     if (!S_ISDIR (entry->ino->st.st_mode))
1192         ERRNOR (ENOTDIR, NULL);
1193
1194     info = g_new (GList *, 1);
1195     *info = g_queue_peek_head_link (entry->ino->subdir);
1196
1197     return info;
1198 }
1199
1200 /* --------------------------------------------------------------------------------------------- */
1201
1202 static struct vfs_dirent *
1203 extfs_readdir (void *data)
1204 {
1205     struct vfs_dirent *dir;
1206     GList **info = (GList **) data;
1207
1208     if (*info == NULL)
1209         return NULL;
1210
1211     dir = vfs_dirent_init (NULL, VFS_ENTRY ((*info)->data)->name, 0);   /* FIXME: inode */
1212
1213     *info = g_list_next (*info);
1214
1215     return dir;
1216 }
1217
1218 /* --------------------------------------------------------------------------------------------- */
1219
1220 static int
1221 extfs_closedir (void *data)
1222 {
1223     g_free (data);
1224     return 0;
1225 }
1226
1227 /* --------------------------------------------------------------------------------------------- */
1228
1229
1230 static void
1231 extfs_stat_move (struct stat *buf, const struct vfs_s_inode *inode)
1232 {
1233     *buf = inode->st;
1234
1235 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1236     buf->st_blksize = RECORDSIZE;
1237 #endif
1238     vfs_adjust_stat (buf);
1239 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1240     buf->st_atim.tv_nsec = buf->st_mtim.tv_nsec = buf->st_ctim.tv_nsec = 0;
1241 #endif
1242 }
1243
1244 /* --------------------------------------------------------------------------------------------- */
1245
1246 static int
1247 extfs_internal_stat (const vfs_path_t *vpath, struct stat *buf, gboolean resolve)
1248 {
1249     struct extfs_super_t *archive;
1250     const char *q;
1251     struct vfs_s_entry *entry;
1252     int result = -1;
1253
1254     q = extfs_get_path (vpath, &archive, FL_NONE);
1255     if (q == NULL)
1256         goto cleanup;
1257     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1258     if (entry == NULL)
1259         goto cleanup;
1260     if (resolve)
1261     {
1262         entry = extfs_resolve_symlinks (entry);
1263         if (entry == NULL)
1264             goto cleanup;
1265     }
1266     extfs_stat_move (buf, entry->ino);
1267     result = 0;
1268   cleanup:
1269     return result;
1270 }
1271
1272 /* --------------------------------------------------------------------------------------------- */
1273
1274 static int
1275 extfs_stat (const vfs_path_t *vpath, struct stat *buf)
1276 {
1277     return extfs_internal_stat (vpath, buf, TRUE);
1278 }
1279
1280 /* --------------------------------------------------------------------------------------------- */
1281
1282 static int
1283 extfs_lstat (const vfs_path_t *vpath, struct stat *buf)
1284 {
1285     return extfs_internal_stat (vpath, buf, FALSE);
1286 }
1287
1288 /* --------------------------------------------------------------------------------------------- */
1289
1290 static int
1291 extfs_fstat (void *fh, struct stat *buf)
1292 {
1293     vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
1294
1295     extfs_stat_move (buf, file->ino);
1296     return 0;
1297 }
1298
1299 /* --------------------------------------------------------------------------------------------- */
1300
1301 static int
1302 extfs_readlink (const vfs_path_t *vpath, char *buf, size_t size)
1303 {
1304     struct extfs_super_t *archive;
1305     const char *q;
1306     size_t len;
1307     struct vfs_s_entry *entry;
1308     int result = -1;
1309
1310     q = extfs_get_path (vpath, &archive, FL_NONE);
1311     if (q == NULL)
1312         goto cleanup;
1313     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1314     if (entry == NULL)
1315         goto cleanup;
1316     if (!S_ISLNK (entry->ino->st.st_mode))
1317     {
1318         VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = EINVAL;
1319         goto cleanup;
1320     }
1321     len = strlen (entry->ino->linkname);
1322     if (size < len)
1323         len = size;
1324     /* readlink() does not append a NUL character to buf */
1325     result = len;
1326     memcpy (buf, entry->ino->linkname, result);
1327   cleanup:
1328     return result;
1329 }
1330
1331 /* --------------------------------------------------------------------------------------------- */
1332
1333 static int
1334 extfs_chown (const vfs_path_t *vpath, uid_t owner, gid_t group)
1335 {
1336     (void) vpath;
1337     (void) owner;
1338     (void) group;
1339     return 0;
1340 }
1341
1342 /* --------------------------------------------------------------------------------------------- */
1343
1344 static int
1345 extfs_chmod (const vfs_path_t *vpath, mode_t mode)
1346 {
1347     (void) vpath;
1348     (void) mode;
1349     return 0;
1350 }
1351
1352 /* --------------------------------------------------------------------------------------------- */
1353
1354 static ssize_t
1355 extfs_write (void *fh, const char *buf, size_t nbyte)
1356 {
1357     vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
1358
1359     file->changed = TRUE;
1360     return write (file->handle, buf, nbyte);
1361 }
1362
1363 /* --------------------------------------------------------------------------------------------- */
1364
1365 static int
1366 extfs_unlink (const vfs_path_t *vpath)
1367 {
1368     struct extfs_super_t *archive;
1369     const char *q;
1370     struct vfs_s_entry *entry;
1371     int result = -1;
1372
1373     q = extfs_get_path (vpath, &archive, FL_NONE);
1374     if (q == NULL)
1375         goto cleanup;
1376     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1377     if (entry == NULL)
1378         goto cleanup;
1379     entry = extfs_resolve_symlinks (entry);
1380     if (entry == NULL)
1381         goto cleanup;
1382     if (S_ISDIR (entry->ino->st.st_mode))
1383     {
1384         VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = EISDIR;
1385         goto cleanup;
1386     }
1387     if (extfs_cmd (" rm ", archive, entry, ""))
1388     {
1389         my_errno = EIO;
1390         goto cleanup;
1391     }
1392     vfs_s_free_entry (VFS_SUPER (archive)->me, entry);
1393     result = 0;
1394   cleanup:
1395     return result;
1396 }
1397
1398 /* --------------------------------------------------------------------------------------------- */
1399
1400 static int
1401 extfs_mkdir (const vfs_path_t *vpath, mode_t mode)
1402 {
1403     struct extfs_super_t *archive;
1404     const char *q;
1405     struct vfs_s_entry *entry;
1406     int result = -1;
1407     struct vfs_class *me;
1408
1409     (void) mode;
1410
1411     me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
1412     q = extfs_get_path (vpath, &archive, FL_NONE);
1413     if (q == NULL)
1414         goto cleanup;
1415     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1416     if (entry != NULL)
1417     {
1418         me->verrno = EEXIST;
1419         goto cleanup;
1420     }
1421     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_MKDIR);
1422     if (entry == NULL)
1423         goto cleanup;
1424     entry = extfs_resolve_symlinks (entry);
1425     if (entry == NULL)
1426         goto cleanup;
1427     if (!S_ISDIR (entry->ino->st.st_mode))
1428     {
1429         me->verrno = ENOTDIR;
1430         goto cleanup;
1431     }
1432
1433     if (extfs_cmd (" mkdir ", archive, entry, ""))
1434     {
1435         my_errno = EIO;
1436         vfs_s_free_entry (VFS_SUPER (archive)->me, entry);
1437         goto cleanup;
1438     }
1439     result = 0;
1440   cleanup:
1441     return result;
1442 }
1443
1444 /* --------------------------------------------------------------------------------------------- */
1445
1446 static int
1447 extfs_rmdir (const vfs_path_t *vpath)
1448 {
1449     struct extfs_super_t *archive;
1450     const char *q;
1451     struct vfs_s_entry *entry;
1452     int result = -1;
1453
1454     q = extfs_get_path (vpath, &archive, FL_NONE);
1455     if (q == NULL)
1456         goto cleanup;
1457     entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
1458     if (entry == NULL)
1459         goto cleanup;
1460     entry = extfs_resolve_symlinks (entry);
1461     if (entry == NULL)
1462         goto cleanup;
1463     if (!S_ISDIR (entry->ino->st.st_mode))
1464     {
1465         VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = ENOTDIR;
1466         goto cleanup;
1467     }
1468
1469     if (extfs_cmd (" rmdir ", archive, entry, ""))
1470     {
1471         my_errno = EIO;
1472         goto cleanup;
1473     }
1474     vfs_s_free_entry (VFS_SUPER (archive)->me, entry);
1475     result = 0;
1476   cleanup:
1477     return result;
1478 }
1479
1480 /* --------------------------------------------------------------------------------------------- */
1481
1482 static int
1483 extfs_chdir (const vfs_path_t *vpath)
1484 {
1485     void *data;
1486
1487     my_errno = ENOTDIR;
1488     data = extfs_opendir (vpath);
1489     if (data == NULL)
1490         return (-1);
1491     extfs_closedir (data);
1492     my_errno = 0;
1493     return 0;
1494 }
1495
1496 /* --------------------------------------------------------------------------------------------- */
1497
1498 static off_t
1499 extfs_lseek (void *fh, off_t offset, int whence)
1500 {
1501     vfs_file_handler_t *file = VFS_FILE_HANDLER (fh);
1502
1503     return lseek (file->handle, offset, whence);
1504 }
1505
1506 /* --------------------------------------------------------------------------------------------- */
1507
1508 static vfsid
1509 extfs_getid (const vfs_path_t *vpath)
1510 {
1511     struct extfs_super_t *archive = NULL;
1512     const char *p;
1513
1514     p = extfs_get_path (vpath, &archive, FL_NO_OPEN);
1515     return (p == NULL ? NULL : (vfsid) archive);
1516 }
1517
1518 /* --------------------------------------------------------------------------------------------- */
1519
1520 static vfs_path_t *
1521 extfs_getlocalcopy (const vfs_path_t *vpath)
1522 {
1523     vfs_file_handler_t *fh;
1524     vfs_path_t *p;
1525
1526     fh = VFS_FILE_HANDLER (extfs_open (vpath, O_RDONLY, 0));
1527     if (fh == NULL)
1528         return NULL;
1529     if (fh->ino->localname == NULL)
1530     {
1531         extfs_close ((void *) fh);
1532         return NULL;
1533     }
1534     p = vfs_path_from_str (fh->ino->localname);
1535     VFS_FILE_HANDLER_SUPER (fh)->fd_usage++;
1536     extfs_close ((void *) fh);
1537     return p;
1538 }
1539
1540 /* --------------------------------------------------------------------------------------------- */
1541
1542 static int
1543 extfs_ungetlocalcopy (const vfs_path_t *vpath, const vfs_path_t *local, gboolean has_changed)
1544 {
1545     vfs_file_handler_t *fh;
1546
1547     fh = VFS_FILE_HANDLER (extfs_open (vpath, O_RDONLY, 0));
1548     if (fh == NULL)
1549         return 0;
1550
1551     if (strcmp (fh->ino->localname, vfs_path_get_last_path_str (local)) == 0)
1552     {
1553         VFS_FILE_HANDLER_SUPER (fh)->fd_usage--;
1554         if (has_changed)
1555             fh->changed = TRUE;
1556         extfs_close ((void *) fh);
1557         return 0;
1558     }
1559     else
1560     {
1561         /* Should not happen */
1562         extfs_close ((void *) fh);
1563         return 0;
1564     }
1565 }
1566
1567 /* --------------------------------------------------------------------------------------------- */
1568
1569 static gboolean
1570 extfs_get_plugins (const char *where, gboolean silent)
1571 {
1572     char *dirname;
1573     GDir *dir;
1574     const char *filename;
1575
1576     dirname = g_build_path (PATH_SEP_STR, where, MC_EXTFS_DIR, (char *) NULL);
1577     dir = g_dir_open (dirname, 0, NULL);
1578
1579     /* We may not use vfs_die() message or message or similar,
1580      * UI is not initialized at this time and message would not
1581      * appear on screen. */
1582     if (dir == NULL)
1583     {
1584         if (!silent)
1585             fprintf (stderr, _("Warning: cannot open %s directory\n"), dirname);
1586         g_free (dirname);
1587         return FALSE;
1588     }
1589
1590     if (extfs_plugins == NULL)
1591         extfs_plugins = g_array_sized_new (FALSE, TRUE, sizeof (extfs_plugin_info_t), 32);
1592
1593     while ((filename = g_dir_read_name (dir)) != NULL)
1594     {
1595         char fullname[MC_MAXPATHLEN];
1596         struct stat s;
1597
1598         g_snprintf (fullname, sizeof (fullname), "%s" PATH_SEP_STR "%s", dirname, filename);
1599
1600         if ((stat (fullname, &s) == 0) && S_ISREG (s.st_mode) && !S_ISDIR (s.st_mode)
1601             && is_exe (s.st_mode))
1602         {
1603             int f;
1604
1605             f = open (fullname, O_RDONLY);
1606
1607             if (f >= 0)
1608             {
1609                 size_t len, i;
1610                 extfs_plugin_info_t info;
1611                 gboolean found = FALSE;
1612
1613                 close (f);
1614
1615                 /* Handle those with a trailing '+', those flag that the
1616                  * file system does not require an archive to work
1617                  */
1618                 len = strlen (filename);
1619                 info.need_archive = (filename[len - 1] != '+');
1620                 info.path = g_strconcat (dirname, PATH_SEP_STR, (char *) NULL);
1621                 info.prefix = g_strndup (filename, len);
1622
1623                 /* prepare to compare file names without trailing '+' */
1624                 if (!info.need_archive)
1625                     info.prefix[len - 1] = '\0';
1626
1627                 /* don't overload already found plugin */
1628                 for (i = 0; i < extfs_plugins->len && !found; i++)
1629                 {
1630                     extfs_plugin_info_t *p;
1631
1632                     p = &g_array_index (extfs_plugins, extfs_plugin_info_t, i);
1633
1634                     /* 2 files with same names cannot be in a directory */
1635                     found = strcmp (info.path, p->path) != 0
1636                         && strcmp (info.prefix, p->prefix) == 0;
1637                 }
1638
1639                 if (found)
1640                 {
1641                     g_free (info.path);
1642                     g_free (info.prefix);
1643                 }
1644                 else
1645                 {
1646                     /* restore file name */
1647                     if (!info.need_archive)
1648                         info.prefix[len - 1] = '+';
1649                     g_array_append_val (extfs_plugins, info);
1650                 }
1651             }
1652         }
1653     }
1654
1655     g_dir_close (dir);
1656     g_free (dirname);
1657
1658     return TRUE;
1659 }
1660
1661 /* --------------------------------------------------------------------------------------------- */
1662
1663 static int
1664 extfs_init (struct vfs_class *me)
1665 {
1666     gboolean d1, d2;
1667
1668     (void) me;
1669
1670     /* 1st: scan user directory */
1671     d1 = extfs_get_plugins (mc_config_get_data_path (), TRUE);  /* silent about user dir */
1672     /* 2nd: scan system dir */
1673     d2 = extfs_get_plugins (LIBEXECDIR, d1);
1674
1675     return (d1 || d2 ? 1 : 0);
1676 }
1677
1678 /* --------------------------------------------------------------------------------------------- */
1679
1680 static void
1681 extfs_done (struct vfs_class *me)
1682 {
1683     size_t i;
1684
1685     while (VFS_SUBCLASS (me)->supers != NULL)
1686         me->free ((vfsid) VFS_SUBCLASS (me)->supers->data);
1687
1688     if (extfs_plugins == NULL)
1689         return;
1690
1691     for (i = 0; i < extfs_plugins->len; i++)
1692     {
1693         extfs_plugin_info_t *info;
1694
1695         info = &g_array_index (extfs_plugins, extfs_plugin_info_t, i);
1696         g_free (info->path);
1697         g_free (info->prefix);
1698     }
1699
1700     g_array_free (extfs_plugins, TRUE);
1701 }
1702
1703 /* --------------------------------------------------------------------------------------------- */
1704
1705 static int
1706 extfs_setctl (const vfs_path_t *vpath, int ctlop, void *arg)
1707 {
1708     (void) arg;
1709
1710     if (ctlop == VFS_SETCTL_RUN)
1711     {
1712         extfs_run (vpath);
1713         return 1;
1714     }
1715     return 0;
1716 }
1717
1718 /* --------------------------------------------------------------------------------------------- */
1719 /*** public functions ****************************************************************************/
1720 /* --------------------------------------------------------------------------------------------- */
1721
1722 void
1723 vfs_init_extfs (void)
1724 {
1725     vfs_init_subclass (&extfs_subclass, "extfs", VFSF_UNKNOWN, NULL);
1726     vfs_extfs_ops->init = extfs_init;
1727     vfs_extfs_ops->done = extfs_done;
1728     vfs_extfs_ops->fill_names = extfs_fill_names;
1729     vfs_extfs_ops->which = extfs_which;
1730     vfs_extfs_ops->open = extfs_open;
1731     vfs_extfs_ops->close = extfs_close;
1732     vfs_extfs_ops->read = extfs_read;
1733     vfs_extfs_ops->write = extfs_write;
1734     vfs_extfs_ops->opendir = extfs_opendir;
1735     vfs_extfs_ops->readdir = extfs_readdir;
1736     vfs_extfs_ops->closedir = extfs_closedir;
1737     vfs_extfs_ops->stat = extfs_stat;
1738     vfs_extfs_ops->lstat = extfs_lstat;
1739     vfs_extfs_ops->fstat = extfs_fstat;
1740     vfs_extfs_ops->chmod = extfs_chmod;
1741     vfs_extfs_ops->chown = extfs_chown;
1742     vfs_extfs_ops->readlink = extfs_readlink;
1743     vfs_extfs_ops->unlink = extfs_unlink;
1744     vfs_extfs_ops->chdir = extfs_chdir;
1745     vfs_extfs_ops->ferrno = extfs_errno;
1746     vfs_extfs_ops->lseek = extfs_lseek;
1747     vfs_extfs_ops->getid = extfs_getid;
1748     vfs_extfs_ops->getlocalcopy = extfs_getlocalcopy;
1749     vfs_extfs_ops->ungetlocalcopy = extfs_ungetlocalcopy;
1750     vfs_extfs_ops->mkdir = extfs_mkdir;
1751     vfs_extfs_ops->rmdir = extfs_rmdir;
1752     vfs_extfs_ops->setctl = extfs_setctl;
1753     extfs_subclass.free_inode = extfs_free_inode;
1754     extfs_subclass.free_archive = extfs_free_archive;
1755     vfs_register_class (vfs_extfs_ops);
1756 }
1757
1758 /* --------------------------------------------------------------------------------------------- */