src/vfs/sfs/sfs.c

   1 /*
   2  * Single File fileSystem
   3  *
   4  * Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   5  * Free Software Foundation, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * \file
  24  * \brief Source: Single File fileSystem
  25  *
  26  * This defines whole class of filesystems which contain single file
  27  * inside. It is somehow similar to extfs, except that extfs makes
  28  * whole virtual trees and we do only single virtual files.
  29  *
  30  * If you want to gunzip something, you should open it with \verbatim #ugz \endverbatim
  31  * suffix, DON'T try to gunzip it yourself.
  32  *
  33  * Namespace: exports vfs_sfs_ops
  34  */
  35
  36 #include <config.h>
  37 #include <errno.h>
  38 #include <sys/types.h>
  39 #include <unistd.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <fcntl.h>
  43
  44 #include "lib/global.h"
  45 #include "lib/util.h"
  46 #include "lib/widget.h"         /* D_ERROR, D_NORMAL */
  47
  48 #include "src/execute.h"        /* EXECUTE_AS_SHELL */
  49
  50 #include "lib/vfs/vfs.h"
  51 #include "lib/vfs/utilvfs.h"
  52 #include "src/vfs/local/local.h"
  53 #include "lib/vfs/gc.h"         /* vfs_stamp_create */
  54
  55 #include "sfs.h"
  56
  57 /*** global variables ****************************************************************************/
  58
  59 /*** file scope macro definitions ****************************************************************/
  60
  61 #define MAXFS 32
  62
  63 #define F_1 1
  64 #define F_2 2
  65 #define F_NOLOCALCOPY 4
  66 #define F_FULLMATCH 8
  67
  68 #define COPY_CHAR \
  69     if ((size_t) (t - pad) > sizeof(pad)) \
  70     { \
  71         g_free (pqname); \
  72         return -1; \
  73     } \
  74     else \
  75         *t++ = *s;
  76
  77 #define COPY_STRING(a) \
  78     if ((t - pad) + strlen(a) > sizeof(pad)) \
  79     { \
  80         g_free (pqname); \
  81         return -1; \
  82     } \
  83     else \
  84     { \
  85         strcpy (t, a); \
  86         t += strlen (a); \
  87     }
  88
  89 /*** file scope type declarations ****************************************************************/
  90
  91 typedef struct cachedfile
  92 {
  93     char *name;
  94     char *cache;
  95 } cachedfile;
  96
  97 /*** file scope variables ************************************************************************/
  98
  99 static GSList *head;
 100 static struct vfs_class vfs_sfs_ops;
 101
 102 static int sfs_no = 0;
 103 static char *sfs_prefix[MAXFS];
 104 static char *sfs_command[MAXFS];
 105 static int sfs_flags[MAXFS];
 106
 107 /*** file scope functions ************************************************************************/
 108
 109 static int
 110 cachedfile_compare (const void *a, const void *b)
 111 {
 112     const cachedfile *cf = (const cachedfile *) a;
 113     const char *name = (const char *) b;
 114
 115     return strcmp (name, cf->name);
 116 }
 117
 118 /* --------------------------------------------------------------------------------------------- */
 119
 120 static int
 121 sfs_vfmake (struct vfs_class *me, const char *name, char *cache)
 122 {
 123     char *inpath, *op;
 124     int w;
 125     char pad[10240];
 126     char *s, *t = pad;
 127     int was_percent = 0;
 128     char *pname;                /* name of parent archive */
 129     char *pqname;               /* name of parent archive, quoted */
 130
 131     pname = g_strdup (name);
 132     vfs_split (pname, &inpath, &op);
 133     w = (*me->which) (me, op);
 134     if (w == -1)
 135         vfs_die ("This cannot happen... Hopefully.\n");
 136
 137     if (!(sfs_flags[w] & F_1) && strcmp (pname, "/"))
 138     {
 139         g_free (pname);
 140         return -1;
 141     }
 142
 143     /*    if ((sfs_flags[w] & F_2) || (!inpath) || (!*inpath)); else return -1; */
 144     if (!(sfs_flags[w] & F_NOLOCALCOPY))
 145     {
 146         s = mc_getlocalcopy (pname);
 147         if (!s)
 148         {
 149             g_free (pname);
 150             return -1;
 151         }
 152         pqname = name_quote (s, 0);
 153         g_free (s);
 154     }
 155     else
 156     {
 157         pqname = name_quote (pname, 0);
 158     }
 159     g_free (pname);
 160
 161
 162     for (s = sfs_command[w]; *s; s++)
 163     {
 164         if (was_percent)
 165         {
 166
 167             const char *ptr = NULL;
 168             was_percent = 0;
 169
 170             switch (*s)
 171             {
 172             case '1':
 173                 ptr = pqname;
 174                 break;
 175             case '2':
 176                 ptr = op + strlen (sfs_prefix[w]);
 177                 break;
 178             case '3':
 179                 ptr = cache;
 180                 break;
 181             case '%':
 182                 COPY_CHAR;
 183                 continue;
 184             }
 185             COPY_STRING (ptr);
 186         }
 187         else
 188         {
 189             if (*s == '%')
 190                 was_percent = 1;
 191             else
 192                 COPY_CHAR;
 193         }
 194     }
 195
 196     g_free (pqname);
 197     open_error_pipe ();
 198     if (my_system (EXECUTE_AS_SHELL, "/bin/sh", pad))
 199     {
 200         close_error_pipe (D_ERROR, NULL);
 201         return -1;
 202     }
 203
 204     close_error_pipe (D_NORMAL, NULL);
 205     return 0;                   /* OK */
 206 }
 207
 208 /* --------------------------------------------------------------------------------------------- */
 209
 210 static const char *
 211 sfs_redirect (struct vfs_class *me, const char *name)
 212 {
 213     GSList *cur;
 214     cachedfile *cf;
 215     char *cache;
 216     int handle;
 217
 218     cur = g_slist_find_custom (head, name, cachedfile_compare);
 219     if (cur != NULL)
 220     {
 221         cf = (cachedfile *) cur->data;
 222         vfs_stamp (&vfs_sfs_ops, cf);
 223         return cf->cache;
 224     }
 225
 226     handle = vfs_mkstemps (&cache, "sfs", name);
 227
 228     if (handle == -1)
 229         return "/SOMEONE_PLAYING_DIRTY_TMP_TRICKS_ON_US";
 230
 231     close (handle);
 232
 233     if (sfs_vfmake (me, name, cache) == 0)
 234     {
 235         cf = g_new (cachedfile, 1);
 236         cf->name = g_strdup (name);
 237         cf->cache = cache;
 238         head = g_slist_prepend (head, cf);
 239
 240         vfs_stamp_create (&vfs_sfs_ops, (cachedfile *) head->data);
 241         return cache;
 242     }
 243
 244     unlink (cache);
 245     g_free (cache);
 246     return "/I_MUST_NOT_EXIST";
 247 }
 248
 249 /* --------------------------------------------------------------------------------------------- */
 250
 251 static void *
 252 sfs_open (const vfs_path_t * vpath /*struct vfs_class *me, const char *path */ , int flags,
 253           mode_t mode)
 254 {
 255     int *sfs_info;
 256     int fd;
 257     const char *path;
 258     vfs_path_element_t *path_element;
 259
 260     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
 261     path = sfs_redirect (path_element->class, vpath->unparsed);
 262     fd = open (path, NO_LINEAR (flags), mode);
 263     if (fd == -1)
 264         return 0;
 265
 266     sfs_info = g_new (int, 1);
 267     *sfs_info = fd;
 268
 269     return sfs_info;
 270 }
 271
 272 /* --------------------------------------------------------------------------------------------- */
 273
 274 static int
 275 sfs_stat (struct vfs_class *me, const char *path, struct stat *buf)
 276 {
 277     path = sfs_redirect (me, path);
 278     return stat (path, buf);
 279 }
 280
 281 /* --------------------------------------------------------------------------------------------- */
 282
 283 static int
 284 sfs_lstat (struct vfs_class *me, const char *path, struct stat *buf)
 285 {
 286     path = sfs_redirect (me, path);
 287 #ifndef HAVE_STATLSTAT
 288     return lstat (path, buf);
 289 #else
 290     return statlstat (path, buf);
 291 #endif
 292 }
 293
 294 /* --------------------------------------------------------------------------------------------- */
 295
 296 static int
 297 sfs_chmod (struct vfs_class *me, const char *path, int mode)
 298 {
 299     path = sfs_redirect (me, path);
 300     return chmod (path, mode);
 301 }
 302
 303 /* --------------------------------------------------------------------------------------------- */
 304
 305 static int
 306 sfs_chown (struct vfs_class *me, const char *path, uid_t owner, gid_t group)
 307 {
 308     path = sfs_redirect (me, path);
 309     return chown (path, owner, group);
 310 }
 311
 312 /* --------------------------------------------------------------------------------------------- */
 313
 314 static int
 315 sfs_utime (struct vfs_class *me, const char *path, struct utimbuf *times)
 316 {
 317     path = sfs_redirect (me, path);
 318     return utime (path, times);
 319 }
 320
 321 /* --------------------------------------------------------------------------------------------- */
 322
 323 static int
 324 sfs_readlink (struct vfs_class *me, const char *path, char *buf, size_t size)
 325 {
 326     path = sfs_redirect (me, path);
 327     return readlink (path, buf, size);
 328 }
 329
 330 /* --------------------------------------------------------------------------------------------- */
 331
 332 static vfsid
 333 sfs_getid (struct vfs_class *me, const char *path)
 334 {
 335     GSList *cur;
 336
 337     (void) me;
 338
 339     cur = g_slist_find_custom (head, path, cachedfile_compare);
 340
 341     return (vfsid) (cur != NULL ? cur->data : NULL);
 342 }
 343
 344 /* --------------------------------------------------------------------------------------------- */
 345
 346 static void
 347 sfs_free (vfsid id)
 348 {
 349     struct cachedfile *which;
 350     GSList *cur;
 351
 352     which = (struct cachedfile *) id;
 353     cur = g_slist_find (head, which);
 354     if (cur == NULL)
 355         vfs_die ("Free of thing which is unknown to me\n");
 356
 357     which = (struct cachedfile *) cur->data;
 358     unlink (which->cache);
 359     g_free (which->cache);
 360     g_free (which->name);
 361     g_free (which);
 362
 363     head = g_slist_delete_link (head, cur);
 364 }
 365
 366 /* --------------------------------------------------------------------------------------------- */
 367
 368 static void
 369 sfs_fill_names (struct vfs_class *me, fill_names_f func)
 370 {
 371     GSList *cur;
 372
 373     (void) me;
 374
 375     for (cur = head; cur != NULL; cur = g_slist_next (cur))
 376         func (((cachedfile *) cur->data)->name);
 377 }
 378
 379 /* --------------------------------------------------------------------------------------------- */
 380
 381 static int
 382 sfs_nothingisopen (vfsid id)
 383 {
 384     /* FIXME: Investigate whether have to guard this like in
 385        the other VFSs (see fd_usage in extfs) -- Norbert */
 386     (void) id;
 387     return 1;
 388 }
 389
 390 /* --------------------------------------------------------------------------------------------- */
 391
 392 static char *
 393 sfs_getlocalcopy (const vfs_path_t * vpath)
 394 {
 395     vfs_path_element_t *path_element;
 396     const char *path;
 397
 398     path_element = vfs_path_get_by_index (vpath, vfs_path_length (vpath) - 1);
 399     path = sfs_redirect (path_element->class, vpath->unparsed);
 400     return g_strdup (path);
 401 }
 402
 403 /* --------------------------------------------------------------------------------------------- */
 404
 405 static int
 406 sfs_ungetlocalcopy (const vfs_path_t * vpath, const char *local, int has_changed)
 407 {
 408     (void) vpath;
 409     (void) local;
 410     (void) has_changed;
 411     return 0;
 412 }
 413
 414 /* --------------------------------------------------------------------------------------------- */
 415
 416 static int
 417 sfs_init (struct vfs_class *me)
 418 {
 419     char *mc_sfsini;
 420     FILE *cfg;
 421     char key[256];
 422
 423     (void) me;
 424
 425     mc_sfsini = g_build_filename (mc_global.sysconfig_dir, "sfs.ini", (char *) NULL);
 426     cfg = fopen (mc_sfsini, "r");
 427
 428     if (cfg == NULL)
 429     {
 430         fprintf (stderr, _("%s: Warning: file %s not found\n"), "sfs_init()", mc_sfsini);
 431         g_free (mc_sfsini);
 432         return 0;
 433     }
 434     g_free (mc_sfsini);
 435
 436     sfs_no = 0;
 437     while (sfs_no < MAXFS && fgets (key, sizeof (key), cfg))
 438     {
 439         char *c, *semi = NULL, flags = 0;
 440
 441         if (*key == '#' || *key == '\n')
 442             continue;
 443
 444         for (c = key; *c; c++)
 445             if ((*c == ':') || (*c == '/'))
 446             {
 447                 semi = c;
 448                 if (*c == '/')
 449                 {
 450                     *c = 0;
 451                     flags |= F_FULLMATCH;
 452                 }
 453                 break;
 454             }
 455
 456         if (!semi)
 457         {
 458           invalid_line:
 459             fprintf (stderr, _("Warning: Invalid line in %s:\n%s\n"), "sfs.ini", key);
 460             continue;
 461         }
 462
 463         c = semi + 1;
 464         while (*c && (*c != ' ') && (*c != '\t'))
 465         {
 466             switch (*c)
 467             {
 468             case '1':
 469                 flags |= F_1;
 470                 break;
 471             case '2':
 472                 flags |= F_2;
 473                 break;
 474             case 'R':
 475                 flags |= F_NOLOCALCOPY;
 476                 break;
 477             default:
 478                 fprintf (stderr, _("Warning: Invalid flag %c in %s:\n%s\n"), *c, "sfs.ini", key);
 479             }
 480             c++;
 481         }
 482         if (!*c)
 483             goto invalid_line;
 484
 485         c++;
 486         *(semi + 1) = 0;
 487         semi = strchr (c, '\n');
 488         if (semi != NULL)
 489             *semi = 0;
 490
 491         sfs_prefix[sfs_no] = g_strdup (key);
 492         sfs_command[sfs_no] = g_strdup (c);
 493         sfs_flags[sfs_no] = flags;
 494         sfs_no++;
 495     }
 496     fclose (cfg);
 497     return 1;
 498 }
 499
 500 /* --------------------------------------------------------------------------------------------- */
 501
 502 static void
 503 sfs_done (struct vfs_class *me)
 504 {
 505     int i;
 506
 507     (void) me;
 508
 509     for (i = 0; i < sfs_no; i++)
 510     {
 511         g_free (sfs_prefix[i]);
 512         g_free (sfs_command[i]);
 513         sfs_prefix[i] = sfs_command[i] = NULL;
 514     }
 515     sfs_no = 0;
 516 }
 517
 518 /* --------------------------------------------------------------------------------------------- */
 519
 520 static int
 521 sfs_which (struct vfs_class *me, const char *path)
 522 {
 523     int i;
 524
 525     (void) me;
 526
 527     for (i = 0; i < sfs_no; i++)
 528         if (sfs_flags[i] & F_FULLMATCH)
 529         {
 530             if (!strcmp (path, sfs_prefix[i]))
 531                 return i;
 532         }
 533         else if (!strncmp (path, sfs_prefix[i], strlen (sfs_prefix[i])))
 534             return i;
 535
 536     return -1;
 537 }
 538
 539 /* --------------------------------------------------------------------------------------------- */
 540 /*** public functions ****************************************************************************/
 541 /* --------------------------------------------------------------------------------------------- */
 542
 543 void
 544 init_sfs (void)
 545 {
 546     vfs_sfs_ops.name = "sfs";
 547     vfs_sfs_ops.init = sfs_init;
 548     vfs_sfs_ops.done = sfs_done;
 549     vfs_sfs_ops.fill_names = sfs_fill_names;
 550     vfs_sfs_ops.which = sfs_which;
 551     vfs_sfs_ops.open = sfs_open;
 552     vfs_sfs_ops.close = local_close;
 553     vfs_sfs_ops.read = local_read;
 554     vfs_sfs_ops.stat = sfs_stat;
 555     vfs_sfs_ops.lstat = sfs_lstat;
 556     vfs_sfs_ops.fstat = local_fstat;
 557     vfs_sfs_ops.chmod = sfs_chmod;
 558     vfs_sfs_ops.chown = sfs_chown;
 559     vfs_sfs_ops.utime = sfs_utime;
 560     vfs_sfs_ops.readlink = sfs_readlink;
 561     vfs_sfs_ops.ferrno = local_errno;
 562     vfs_sfs_ops.lseek = local_lseek;
 563     vfs_sfs_ops.getid = sfs_getid;
 564     vfs_sfs_ops.nothingisopen = sfs_nothingisopen;
 565     vfs_sfs_ops.free = sfs_free;
 566     vfs_sfs_ops.getlocalcopy = sfs_getlocalcopy;
 567     vfs_sfs_ops.ungetlocalcopy = sfs_ungetlocalcopy;
 568     vfs_register_class (&vfs_sfs_ops);
 569 }
 570
 571 /* --------------------------------------------------------------------------------------------- */