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 | EXECUTE_SETUID | EXECUTE_WAIT, "/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, 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
 264 static void sfs_fill_names (vfs *me, void (*func)(char *))
 265 {
 266     struct cachedfile *cur = head;
 267
 268     while (cur){
 269         (*func)(cur->name);
 270         cur = cur->next;
 271     }
 272 }
 273
 274 static int sfs_nothingisopen (vfsid id)
 275 {
 276     /* FIXME: Investigate whether have to guard this like in
 277        the other VFSs (see fd_usage in extfs) -- Norbert */
 278     return 1;
 279 }
 280
 281 static char *sfs_getlocalcopy (vfs *me, char *path)
 282 {
 283     path = redirect (me, path);
 284     return g_strdup (path);
 285 }
 286
 287 static int sfs_ungetlocalcopy (vfs *me, char *path, char *local, int has_changed)
 288 {
 289     g_free(local);
 290     return 0;
 291 }
 292
 293 static int sfs_init (vfs *me)
 294 {
 295     char *mc_sfsini;
 296     FILE *cfg;
 297
 298     mc_sfsini = concat_dir_and_file (mc_home, "extfs/sfs.ini");
 299     cfg = fopen (mc_sfsini, "r");
 300
 301     if (!cfg){
 302         fprintf (stderr, _("Warning: file %s not found\n"), mc_sfsini);
 303         g_free (mc_sfsini);
 304         return 0;
 305     }
 306     g_free (mc_sfsini);
 307
 308     sfs_no = 0;
 309     while (sfs_no < MAXFS){
 310         char key[256];
 311         char *c, *semi = NULL, flags = 0;
 312
 313         if (!fgets (key, sizeof (key), cfg))
 314             break;
 315
 316         if (*key == '#')
 317             continue;
 318
 319         for (c = key; *c; c++)
 320             if ((*c == ':') || (*c == '/')){
 321                 semi = c;
 322                 if (*c == '/'){
 323                     *c = 0;
 324                     flags |= F_FULLMATCH;
 325                 }
 326                 break;
 327             }
 328
 329         if (!semi){
 330             fprintf (stderr, _("Warning: Invalid line in sfs.ini:\n%s\n"), key);
 331             continue;
 332         }
 333
 334         c = semi + 1;
 335         while ((*c != ' ') && (*c != '\t')) {
 336             switch (*c) {
 337             case '1': flags |= F_1; break;
 338             case '2': flags |= F_2; break;
 339             case 'R': flags |= F_NOLOCALCOPY; break;
 340             default:
 341               fprintf (stderr, _("Warning: Invalid flag %c in sfs.ini:\n%s\n"), *c, key);
 342             }
 343             c++;
 344         }
 345         c++;
 346         *(semi+1) = 0;
 347         if ((semi = strchr (c, '\n')))
 348             *semi = 0;
 349
 350         sfs_prefix [sfs_no] = g_strdup (key);
 351         sfs_command [sfs_no] = g_strdup (c);
 352         sfs_flags [sfs_no] = flags;
 353         sfs_no++;
 354     }
 355     fclose (cfg);
 356     return 1;
 357 }
 358
 359 static void
 360 sfs_done (vfs *me)
 361 {
 362     int i;
 363
 364     for (i = 0; i < sfs_no; i++){
 365         g_free (sfs_prefix [i]);
 366         g_free (sfs_command [i]);
 367         sfs_prefix [i] = sfs_command [i] = NULL;
 368     }
 369     sfs_no = 0;
 370 }
 371
 372 static int
 373 sfs_which (vfs *me, char *path)
 374 {
 375     int i;
 376
 377     for (i = 0; i < sfs_no; i++)
 378         if (sfs_flags [i] & F_FULLMATCH) {
 379             if (!strcmp (path, sfs_prefix [i]))
 380                 return i;
 381         } else
 382             if (!strncmp (path, sfs_prefix [i], strlen (sfs_prefix [i])))
 383                 return i;
 384
 385     return -1;
 386 }
 387
 388 vfs vfs_sfs_ops = {
 389     NULL,       /* This is place of next pointer */
 390     "sfs",
 391     F_EXEC,     /* flags */
 392     NULL,       /* prefix */
 393     NULL,       /* data */
 394     0,          /* errno */
 395     sfs_init,
 396     sfs_done,
 397     sfs_fill_names,
 398     sfs_which,
 399
 400     sfs_open,
 401     local_close,
 402     local_read,
 403     NULL,
 404
 405     NULL,
 406     NULL,
 407     NULL,
 408     NULL,
 409     NULL,
 410
 411     sfs_stat,
 412     sfs_lstat,
 413     local_fstat,
 414
 415     sfs_chmod,
 416     sfs_chown,
 417     sfs_utime,
 418
 419     sfs_readlink,
 420     NULL,
 421     NULL,
 422     NULL,
 423
 424     NULL,
 425     NULL,
 426     local_errno,
 427     local_lseek,
 428     NULL,
 429
 430     sfs_getid,
 431     sfs_nothingisopen,
 432     sfs_free,
 433
 434     sfs_getlocalcopy,
 435     sfs_ungetlocalcopy,
 436
 437     NULL,
 438     NULL,
 439     NULL,
 440     NULL
 441
 442 #ifdef HAVE_MMAP
 443     ,local_mmap,
 444     local_munmap
 445 #endif
 446 };
 447