2 * Single File fileSystem
4 * Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
5 * Free Software Foundation, Inc.
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.
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.
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.
21 * This defines whole class of filesystems which contain single file
22 * inside. It is somehow similar to extfs, except that extfs makes
23 * whole virtual trees and we do only single virtual files.
25 * If you want to gunzip something, you should open it with #ugz
26 * suffix, DON'T try to gunzip it yourself.
28 * Namespace: exports vfs_sfs_ops */
32 #include <sys/types.h>
37 #include "../src/global.h"
38 #include "../src/tty.h" /* enable/disable interrupt key */
39 #include "../src/wtools.h" /* message() */
40 #include "../src/main.h" /* print_vfs_message */
44 #include "gc.h" /* vfs_stamp_create */
46 #include "../src/execute.h" /* EXECUTE_AS_SHELL */
50 struct cachedfile
*next
;
53 static struct cachedfile
*head
;
54 static struct vfs_class vfs_sfs_ops
;
57 static int sfs_no
= 0;
58 static char *sfs_prefix
[ MAXFS
];
59 static char *sfs_command
[ MAXFS
];
60 static int sfs_flags
[ MAXFS
];
63 #define F_NOLOCALCOPY 4
67 sfs_vfmake (struct vfs_class
*me
, const char *name
, char *cache
)
74 char *pname
; /* name of parent archive */
75 char *pqname
; /* name of parent archive, quoted */
77 pname
= g_strdup (name
);
78 vfs_split (pname
, &inpath
, &op
);
79 if ((w
= (*me
->which
) (me
, op
)) == -1)
80 vfs_die ("This cannot happen... Hopefully.\n");
82 if (!(sfs_flags
[w
] & F_1
) && strcmp (pname
, "/")) {
87 /* if ((sfs_flags[w] & F_2) || (!inpath) || (!*inpath)); else return -1; */
88 if (!(sfs_flags
[w
] & F_NOLOCALCOPY
)) {
89 s
= mc_getlocalcopy (pname
);
94 pqname
= name_quote (s
, 0);
97 pqname
= name_quote (pname
, 0);
102 if ((size_t) (t-pad) > sizeof(pad)) { \
109 #define COPY_STRING(a) \
110 if ((t-pad)+strlen(a)>sizeof(pad)) { \
118 for (s
= sfs_command
[w
]; *s
; s
++) {
121 const char *ptr
= NULL
;
129 ptr
= op
+ strlen (sfs_prefix
[w
]);
149 if (my_system (EXECUTE_AS_SHELL
, "/bin/sh", pad
)) {
150 close_error_pipe (1, NULL
);
154 close_error_pipe (0, NULL
);
159 sfs_redirect (struct vfs_class
*me
, const char *name
)
161 struct cachedfile
*cur
= head
;
166 if (!strcmp (name
, cur
->name
)) {
167 vfs_stamp (&vfs_sfs_ops
, cur
);
173 handle
= vfs_mkstemps (&cache
, "sfs", name
);
176 return "/SOMEONE_PLAYING_DIRTY_TMP_TRICKS_ON_US";
181 if (!sfs_vfmake (me
, name
, cache
)) {
182 cur
= g_new (struct cachedfile
, 1);
183 cur
->name
= g_strdup (name
);
188 vfs_stamp_create (&vfs_sfs_ops
, head
);
195 return "/I_MUST_NOT_EXIST";
199 sfs_open (struct vfs_class
*me
, const char *path
, int flags
, int mode
)
204 path
= sfs_redirect (me
, path
);
205 fd
= open (path
, NO_LINEAR (flags
), mode
);
209 sfs_info
= g_new (int, 1);
215 static int sfs_stat (struct vfs_class
*me
, const char *path
, struct stat
*buf
)
217 path
= sfs_redirect (me
, path
);
218 return stat (path
, buf
);
221 static int sfs_lstat (struct vfs_class
*me
, const char *path
, struct stat
*buf
)
223 path
= sfs_redirect (me
, path
);
224 #ifndef HAVE_STATLSTAT
225 return lstat (path
, buf
);
227 return statlstat (path
, buf
);
231 static int sfs_chmod (struct vfs_class
*me
, const char *path
, int mode
)
233 path
= sfs_redirect (me
, path
);
234 return chmod (path
, mode
);
237 static int sfs_chown (struct vfs_class
*me
, const char *path
, int owner
, int group
)
239 path
= sfs_redirect (me
, path
);
240 return chown (path
, owner
, group
);
243 static int sfs_utime (struct vfs_class
*me
, const char *path
, struct utimbuf
*times
)
245 path
= sfs_redirect (me
, path
);
246 return utime (path
, times
);
250 sfs_readlink (struct vfs_class
*me
, const char *path
, char *buf
, size_t size
)
252 path
= sfs_redirect (me
, path
);
253 return readlink (path
, buf
, size
);
257 sfs_getid (struct vfs_class
*me
, const char *path
)
259 struct cachedfile
*cur
= head
;
264 if (!strcmp (path
, cur
->name
))
272 static void sfs_free (vfsid id
)
274 struct cachedfile
*which
= (struct cachedfile
*) id
;
275 struct cachedfile
*cur
, *prev
;
277 for (cur
= head
, prev
= 0; cur
&& cur
!= which
; prev
= cur
, cur
= cur
->next
)
280 vfs_die( "Free of thing which is unknown to me\n" );
284 prev
->next
= cur
->next
;
293 static void sfs_fill_names (struct vfs_class
*me
, fill_names_f func
)
295 struct cachedfile
*cur
= head
;
305 static int sfs_nothingisopen (vfsid id
)
307 /* FIXME: Investigate whether have to guard this like in
308 the other VFSs (see fd_usage in extfs) -- Norbert */
314 sfs_getlocalcopy (struct vfs_class
*me
, const char *path
)
316 path
= sfs_redirect (me
, path
);
317 return g_strdup (path
);
321 sfs_ungetlocalcopy (struct vfs_class
*me
, const char *path
,
322 const char *local
, int has_changed
)
331 static int sfs_init (struct vfs_class
*me
)
339 mc_sfsini
= concat_dir_and_file (mc_home
, "extfs" PATH_SEP_STR
"sfs.ini");
340 cfg
= fopen (mc_sfsini
, "r");
343 fprintf (stderr
, _("Warning: file %s not found\n"), mc_sfsini
);
350 while (sfs_no
< MAXFS
&& fgets (key
, sizeof (key
), cfg
)) {
351 char *c
, *semi
= NULL
, flags
= 0;
353 if (*key
== '#' || *key
== '\n')
356 for (c
= key
; *c
; c
++)
357 if ((*c
== ':') || (*c
== '/')){
361 flags
|= F_FULLMATCH
;
368 fprintf (stderr
, _("Warning: Invalid line in %s:\n%s\n"),
374 while (*c
&& (*c
!= ' ') && (*c
!= '\t')) {
376 case '1': flags
|= F_1
; break;
377 case '2': flags
|= F_2
; break;
378 case 'R': flags
|= F_NOLOCALCOPY
; break;
380 fprintf (stderr
, _("Warning: Invalid flag %c in %s:\n%s\n"),
389 if ((semi
= strchr (c
, '\n')))
392 sfs_prefix
[sfs_no
] = g_strdup (key
);
393 sfs_command
[sfs_no
] = g_strdup (c
);
394 sfs_flags
[sfs_no
] = flags
;
402 sfs_done (struct vfs_class
*me
)
408 for (i
= 0; i
< sfs_no
; i
++){
409 g_free (sfs_prefix
[i
]);
410 g_free (sfs_command
[i
]);
411 sfs_prefix
[i
] = sfs_command
[i
] = NULL
;
417 sfs_which (struct vfs_class
*me
, const char *path
)
423 for (i
= 0; i
< sfs_no
; i
++)
424 if (sfs_flags
[i
] & F_FULLMATCH
) {
425 if (!strcmp (path
, sfs_prefix
[i
]))
428 if (!strncmp (path
, sfs_prefix
[i
], strlen (sfs_prefix
[i
])))
437 vfs_sfs_ops
.name
= "sfs";
438 vfs_sfs_ops
.init
= sfs_init
;
439 vfs_sfs_ops
.done
= sfs_done
;
440 vfs_sfs_ops
.fill_names
= sfs_fill_names
;
441 vfs_sfs_ops
.which
= sfs_which
;
442 vfs_sfs_ops
.open
= sfs_open
;
443 vfs_sfs_ops
.close
= local_close
;
444 vfs_sfs_ops
.read
= local_read
;
445 vfs_sfs_ops
.stat
= sfs_stat
;
446 vfs_sfs_ops
.lstat
= sfs_lstat
;
447 vfs_sfs_ops
.fstat
= local_fstat
;
448 vfs_sfs_ops
.chmod
= sfs_chmod
;
449 vfs_sfs_ops
.chown
= sfs_chown
;
450 vfs_sfs_ops
.utime
= sfs_utime
;
451 vfs_sfs_ops
.readlink
= sfs_readlink
;
452 vfs_sfs_ops
.ferrno
= local_errno
;
453 vfs_sfs_ops
.lseek
= local_lseek
;
454 vfs_sfs_ops
.getid
= sfs_getid
;
455 vfs_sfs_ops
.nothingisopen
= sfs_nothingisopen
;
456 vfs_sfs_ops
.free
= sfs_free
;
457 vfs_sfs_ops
.getlocalcopy
= sfs_getlocalcopy
;
458 vfs_sfs_ops
.ungetlocalcopy
= sfs_ungetlocalcopy
;
459 vfs_register_class (&vfs_sfs_ops
);