vfs/sfs.c

   1 /*
   2  * Single File fileSystem
   3  *
   4  * Copyright 1998 Pavel Machek, distribute under GPL
   5  *
   6  * $Id$
   7  *
   8  * This defines whole class of filesystems which contain single file
   9  * inside. It is somehow similar to extfs, except that extfs makes
  10  * whole virtual trees and we do only single virtual files.
  11  *
  12  * If you want to gunzip something, you should open it with #ugz
  13  * suffix, DON'T try to gunzip it yourself.
  14  *
  15  * Namespace: exports vfs_sfs_ops */
  16
  17 #include <config.h>
  18 #include <errno.h>
  19 #include <sys/types.h>
  20 #include <unistd.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <fcntl.h>
  24
  25 #include "utilvfs.h"
  26
  27 #include "vfs.h"
  28 #include "local.h"
  29
  30 struct cachedfile {
  31     char *name, *cache;
  32     uid_t uid;
  33     struct cachedfile *next;
  34 };
  35
  36 static struct cachedfile *head;
  37
  38 #define MAXFS 32
  39 static int sfs_no = 0;
  40 static char *sfs_prefix[ MAXFS ];
  41 static char *sfs_command[ MAXFS ];
  42 static int sfs_flags[ MAXFS ];
  43 #define F_1 1
  44 #define F_2 2
  45 #define F_NOLOCALCOPY 4
  46 #define F_FULLMATCH 8
  47
  48 static int uptodate (char *name, char *cache)
  49 {
  50     return 1;
  51 }
  52
  53 static int vfmake (vfs *me, char *name, char *cache)
  54 {
  55     char *inpath, *op;
  56     int w;
  57     char pad [10240];
  58     char *s, *t = pad;
  59     int was_percent = 0;
  60
  61     vfs_split (name, &inpath, &op);
  62     if ((w = (*me->which) (me, op)) == -1)
  63         vfs_die ("This cannot happen... Hopefully.\n");
  64
  65     if ((sfs_flags[w] & F_1) || (!strcmp (name, "/"))) ; else return -1;
  66     /*    if ((sfs_flags[w] & F_2) || (!inpath) || (!*inpath)); else return -1; */
  67     if (!(sfs_flags[w] & F_NOLOCALCOPY)) {
  68         s = mc_getlocalcopy (name);
  69         if (!s)
  70             return -1;
  71         name = name_quote (s, 0);
  72         g_free (s);
  73     } else
  74         name = name_quote (name, 0);
  75 #define COPY_CHAR if (t-pad>sizeof(pad)) { g_free (name); return -1; } else *t++ = *s;
  76 #define COPY_STRING(a) if ((t-pad)+strlen(a)>sizeof(pad)) { g_free (name); return -1; } else { strcpy (t, a); t+= strlen(a); }
  77     for (s = sfs_command[w]; *s; s++) {
  78         if (was_percent) {
  79
  80             char *ptr = NULL;
  81             was_percent = 0;
  82
  83             switch (*s) {
  84             case '1': ptr = name; break;
  85             case '2': ptr = op + strlen (sfs_prefix[w]); break;
  86             case '3': ptr = cache; break;
  87             case '%': COPY_CHAR; continue;
  88             }
  89             COPY_STRING (ptr);
  90         } else {
  91             if (*s == '%')
  92                 was_percent = 1;
  93             else
  94                 COPY_CHAR;
  95         }
  96     }
  97     g_free (name);
  98
  99     if (my_system (EXECUTE_AS_SHELL, "/bin/sh", pad)) {
 100         return -1;
 101     }
 102
 103     return 0; /* OK */
 104 }
 105
 106 static char *
 107 redirect (vfs *me, char *name)
 108 {
 109     struct cachedfile *cur = head;
 110     uid_t uid = vfs_uid;
 111     char *cache;
 112     int handle;
 113
 114     while (cur){
 115         if ((!strcmp (name, cur->name)) &&
 116             (uid == cur->uid) &&
 117             (uptodate (cur->name, cur->cache)))
 118                 /* FIXME: when not uptodate, we might want to kill cache
 119                  * file immediately, not to wait until timeout. */ {
 120                 vfs_stamp (&vfs_sfs_ops, cur);
 121                 return cur->cache;
 122         }
 123         cur = cur->next;
 124     }
 125
 126     handle = mc_mkstemps (&cache, "sfs", NULL);
 127
 128     if (handle == -1) {
 129         return "/SOMEONE_PLAYING_DIRTY_TMP_TRICKS_ON_US";
 130     }
 131
 132     close (handle);
 133
 134     if (!vfmake (me, name, cache)){
 135         cur = g_new (struct cachedfile, 1);
 136         cur->name = g_strdup (name);
 137         cur->cache = cache;
 138         cur->uid = uid;
 139         cur->next = head;
 140         head = cur;
 141
 142         vfs_add_noncurrent_stamps (&vfs_sfs_ops, (vfsid) head, NULL);
 143         vfs_rm_parents (NULL);
 144
 145         return cache;
 146     }
 147
 148     unlink (cache);
 149     g_free (cache);
 150     return "/I_MUST_NOT_EXIST";
 151 }
 152
 153 static void *
 154 sfs_open (vfs *me, char *path, int flags, int mode)
 155 {
 156     int *sfs_info;
 157     int fd;
 158
 159     path = redirect (me, path);
 160     fd = open (path, NO_LINEAR(flags), mode);
 161     if (fd == -1)
 162         return 0;
 163
 164     sfs_info = g_new (int, 1);
 165     *sfs_info = fd;
 166
 167     return sfs_info;
 168 }
 169
 170 static int sfs_stat (vfs *me, char *path, struct stat *buf)
 171 {
 172     path = redirect (me, path);
 173     return stat (path, buf);
 174 }
 175
 176 static int sfs_lstat (vfs *me, char *path, struct stat *buf)
 177 {
 178     path = redirect (me, path);
 179 #ifndef HAVE_STATLSTAT
 180     return lstat (path, buf);
 181 #else
 182     return statlstat (path, buf);
 183 #endif
 184 }
 185
 186 static int sfs_chmod (vfs *me, char *path, int mode)
 187 {
 188     path = redirect (me, path);
 189     return chmod (path, mode);
 190 }
 191
 192 static int sfs_chown (vfs *me, char *path, int owner, int group)
 193 {
 194     path = redirect (me, path);
 195     return chown (path, owner, group);
 196 }
 197
 198 static int sfs_utime (vfs *me, char *path, struct utimbuf *times)
 199 {
 200     path = redirect (me, path);
 201     return utime (path, times);
 202 }
 203
 204 static int sfs_readlink (vfs *me, char *path, char *buf, int size)
 205 {
 206     path = redirect (me, path);
 207     return readlink (path, buf, size);
 208 }
 209
 210 static vfsid sfs_getid (vfs *me, char *path, struct vfs_stamping **parent)
 211 {       /* FIXME: what should I do? */
 212     vfs *v;
 213     vfsid id;
 214     struct vfs_stamping *par;
 215     struct cachedfile *cur = head;
 216
 217     while (cur) {
 218         if ((!strcmp( path, cur->name )) &&
 219             (vfs_uid == cur->uid))
 220             break;
 221         cur = cur->next;
 222     }
 223
 224     *parent = NULL;
 225
 226     if (!cur)
 227         return (vfsid)(-1);
 228
 229     {
 230         char *path2 = g_strdup (path);
 231         v = vfs_split (path2, NULL, NULL);      /* Strip suffix which led to this being sfs */
 232         v = vfs_split (path2, NULL, NULL);      /* ... and learn whoever was the parent system */
 233         id = (*v->getid) (v, path2, &par);
 234         g_free (path2);
 235     }
 236
 237     if (id != (vfsid)-1) {
 238         *parent = g_new (struct vfs_stamping, 1);
 239         (*parent)->v = v;
 240         (*parent)->id = id;
 241         (*parent)->parent = par;
 242         (*parent)->next = NULL;
 243     }
 244     return (vfsid) cur;
 245 }
 246
 247 static void sfs_free (vfsid id)
 248 {
 249     struct cachedfile *which = (struct cachedfile *) id;
 250     struct cachedfile *cur, *prev;
 251
 252     for (cur = head, prev = 0; cur && cur != which; prev = cur, cur = cur->next)
 253         ;
 254     if (!cur)
 255         vfs_die( "Free of thing which is unknown to me\n" );
 256     unlink (cur->cache);
 257
 258     if (prev)
 259         prev->next = cur->next;
 260     else
 261         head = cur->next;
 262
 263     g_free (cur->cache);
 264     g_free (cur->name);
 265     g_free (cur);
 266 }
 267
 268 static void sfs_fill_names (vfs *me, void (*func)(char *))
 269 {
 270     struct cachedfile *cur = head;
 271
 272     while (cur){
 273         (*func)(cur->name);
 274         cur = cur->next;
 275     }
 276 }
 277
 278 static int sfs_nothingisopen (vfsid id)
 279 {
 280     /* FIXME: Investigate whether have to guard this like in
 281        the other VFSs (see fd_usage in extfs) -- Norbert */
 282     return 1;
 283 }
 284
 285 static char *sfs_getlocalcopy (vfs *me, char *path)
 286 {
 287     path = redirect (me, path);
 288     return g_strdup (path);
 289 }
 290
 291 static int sfs_ungetlocalcopy (vfs *me, char *path, char *local, int has_changed)
 292 {
 293     g_free(local);
 294     return 0;
 295 }
 296
 297 static int sfs_init (vfs *me)
 298 {
 299     char *mc_sfsini;
 300     FILE *cfg;
 301
 302     mc_sfsini = concat_dir_and_file (mc_home, "extfs" PATH_SEP_STR "sfs.ini");
 303     cfg = fopen (mc_sfsini, "r");
 304
 305     if (!cfg){
 306         fprintf (stderr, _("Warning: file %s not found\n"), mc_sfsini);
 307         g_free (mc_sfsini);
 308         return 0;
 309     }
 310     g_free (mc_sfsini);
 311
 312     sfs_no = 0;
 313     while (sfs_no < MAXFS){
 314         char key[256];
 315         char *c, *semi = NULL, flags = 0;
 316
 317         if (!fgets (key, sizeof (key), cfg))
 318             break;
 319
 320         if (*key == '#')
 321             continue;
 322
 323         for (c = key; *c; c++)
 324             if ((*c == ':') || (*c == '/')){
 325                 semi = c;
 326                 if (*c == '/'){
 327                     *c = 0;
 328                     flags |= F_FULLMATCH;
 329                 }
 330                 break;
 331             }
 332
 333         if (!semi){
 334             fprintf (stderr, _("Warning: Invalid line in sfs.ini:\n%s\n"), key);
 335             continue;
 336         }
 337
 338         c = semi + 1;
 339         while ((*c != ' ') && (*c != '\t')) {
 340             switch (*c) {
 341             case '1': flags |= F_1; break;
 342             case '2': flags |= F_2; break;
 343             case 'R': flags |= F_NOLOCALCOPY; break;
 344             default:
 345               fprintf (stderr, _("Warning: Invalid flag %c in sfs.ini:\n%s\n"), *c, key);
 346             }
 347             c++;
 348         }
 349         c++;
 350         *(semi+1) = 0;
 351         if ((semi = strchr (c, '\n')))
 352             *semi = 0;
 353
 354         sfs_prefix [sfs_no] = g_strdup (key);
 355         sfs_command [sfs_no] = g_strdup (c);
 356         sfs_flags [sfs_no] = flags;
 357         sfs_no++;
 358     }
 359     fclose (cfg);
 360     return 1;
 361 }
 362
 363 static void
 364 sfs_done (vfs *me)
 365 {
 366     int i;
 367
 368     for (i = 0; i < sfs_no; i++){
 369         g_free (sfs_prefix [i]);
 370         g_free (sfs_command [i]);
 371         sfs_prefix [i] = sfs_command [i] = NULL;
 372     }
 373     sfs_no = 0;
 374 }
 375
 376 static int
 377 sfs_which (vfs *me, char *path)
 378 {
 379     int i;
 380
 381     for (i = 0; i < sfs_no; i++)
 382         if (sfs_flags [i] & F_FULLMATCH) {
 383             if (!strcmp (path, sfs_prefix [i]))
 384                 return i;
 385         } else
 386             if (!strncmp (path, sfs_prefix [i], strlen (sfs_prefix [i])))
 387                 return i;
 388
 389     return -1;
 390 }
 391
 392 vfs vfs_sfs_ops = {
 393     NULL,       /* This is place of next pointer */
 394     "sfs",
 395     F_EXEC,     /* flags */
 396     NULL,       /* prefix */
 397     NULL,       /* data */
 398     0,          /* errno */
 399     sfs_init,
 400     sfs_done,
 401     sfs_fill_names,
 402     sfs_which,
 403
 404     sfs_open,
 405     local_close,
 406     local_read,
 407     NULL,
 408
 409     NULL,
 410     NULL,
 411     NULL,
 412     NULL,
 413     NULL,
 414
 415     sfs_stat,
 416     sfs_lstat,
 417     local_fstat,
 418
 419     sfs_chmod,
 420     sfs_chown,
 421     sfs_utime,
 422
 423     sfs_readlink,
 424     NULL,
 425     NULL,
 426     NULL,
 427
 428     NULL,
 429     NULL,
 430     local_errno,
 431     local_lseek,
 432     NULL,
 433
 434     sfs_getid,
 435     sfs_nothingisopen,
 436     sfs_free,
 437
 438     sfs_getlocalcopy,
 439     sfs_ungetlocalcopy,
 440
 441     NULL,
 442     NULL,
 443     NULL,
 444     NULL
 445
 446 #ifdef HAVE_MMAP
 447     ,local_mmap,
 448     local_munmap
 449 #endif
 450 };
 451