mirrors/mc
1
0
Fork 0
mirror of https://github.com/MidnightCommander/mc synced 2024-12-22 20:36:50 +03:00
Code Issues Packages Projects Releases Wiki Activity

Use vfs_path_get_last_path_vfs() where it is resonable.

Browse Source
This commit is contained in:
Andrew Borodin 2023-07-16 11:18:59 +03:00
parent e20d9acecb
commit 978ce6d0dd
12 changed files with 174 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
lib/vfs/direntry.c
View File

@ -396,22 +396,22 @@ vfs_s_inode_from_path (const vfs_path_t * vpath, int flags)
struct vfs_s_super *super;
struct vfs_s_inode *ino;
const char *q;
const vfs_path_element_t *path_element;
struct vfs_class *me;
q = vfs_s_get_path (vpath, &super, 0);
if (q == NULL)
return NULL;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ino =
vfs_s_find_inode (path_element->class, super, q,
vfs_s_find_inode (me, super, q,
(flags & FL_FOLLOW) != 0 ? LINK_FOLLOW : LINK_NO_FOLLOW,
flags & ~FL_FOLLOW);
if (ino == NULL && *q == '\0')
/* We are asking about / directory of ftp server: assume it exists */
ino =
vfs_s_find_inode (path_element->class, super, q,
vfs_s_find_inode (me, super, q,
(flags & FL_FOLLOW) != 0 ? LINK_FOLLOW : LINK_NO_FOLLOW,
FL_DIR | (flags & ~FL_FOLLOW));
return ino;
@ -424,17 +424,17 @@ vfs_s_opendir (const vfs_path_t * vpath)
{
struct vfs_s_inode *dir;
struct dirhandle *info;
const vfs_path_element_t *path_element;
struct vfs_class *me;
dir = vfs_s_inode_from_path (vpath, FL_DIR | FL_FOLLOW);
if (dir == NULL)
return NULL;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
if (!S_ISDIR (dir->st.st_mode))
{
path_element->class->verrno = ENOTDIR;
me->verrno = ENOTDIR;
return NULL;
}
@ -442,7 +442,7 @@ vfs_s_opendir (const vfs_path_t * vpath)
#if 0
if (dir->subdir == NULL) /* This can actually happen if we allow empty directories */
{
path_element->class->verrno = EAGAIN;
me->verrno = EAGAIN;
return NULL;
}
#endif
@ -525,23 +525,23 @@ vfs_s_readlink (const vfs_path_t * vpath, char *buf, size_t size)
{
struct vfs_s_inode *ino;
size_t len;
const vfs_path_element_t *path_element;
struct vfs_class *me;
ino = vfs_s_inode_from_path (vpath, 0);
if (ino == NULL)
return (-1);
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
if (!S_ISLNK (ino->st.st_mode))
{
path_element->class->verrno = EINVAL;
me->verrno = EINVAL;
return (-1);
}
if (ino->linkname == NULL)
{
path_element->class->verrno = EFAULT;
me->verrno = EFAULT;
return (-1);
}
@ -765,7 +765,7 @@ vfs_s_getlocalcopy (const vfs_path_t * vpath)
{
const struct vfs_class *me;
me = vfs_path_get_by_index (vpath, -1)->class;
me = vfs_path_get_last_path_vfs (vpath);
if ((me->flags & VFSF_USETMP) != 0 && fh->ino != NULL)
local = vfs_path_from_str_flags (fh->ino->localname, VPF_NO_CANON);
@ -795,9 +795,9 @@ vfs_s_ungetlocalcopy (const vfs_path_t * vpath, const vfs_path_t * local, gboole
static int
vfs_s_setctl (const vfs_path_t * vpath, int ctlop, void *arg)
{
const vfs_path_element_t *path_element;
struct vfs_class *me;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
switch (ctlop)
{
@ -813,15 +813,15 @@ vfs_s_setctl (const vfs_path_t * vpath, int ctlop, void *arg)
else
{
ino->super->want_stale = FALSE;
vfs_s_invalidate (path_element->class, ino->super);
vfs_s_invalidate (me, ino->super);
}
return 1;
}
case VFS_SETCTL_LOGFILE:
path_element->class->logfile = fopen ((char *) arg, "w");
me->logfile = fopen ((char *) arg, "w");
return 1;
case VFS_SETCTL_FLUSH:
path_element->class->flush = TRUE;
me->flush = TRUE;
return 1;
default:
return 0;
@ -1300,23 +1300,23 @@ vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
struct vfs_s_super *super;
const char *q;
struct vfs_s_inode *ino;
const vfs_path_element_t *path_element;
struct vfs_class *me;
struct vfs_s_subclass *s;
q = vfs_s_get_path (vpath, &super, 0);
if (q == NULL)
return NULL;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ino = vfs_s_find_inode (path_element->class, super, q, LINK_FOLLOW, FL_NONE);
ino = vfs_s_find_inode (me, super, q, LINK_FOLLOW, FL_NONE);
if (ino != NULL && (flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
{
path_element->class->verrno = EEXIST;
me->verrno = EEXIST;
return NULL;
}
s = VFS_SUBCLASS (path_element->class);
s = VFS_SUBCLASS (me);
if (ino == NULL)
{
@ -1325,25 +1325,25 @@ vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
struct vfs_s_inode *dir;
/* If the filesystem is read-only, disable file creation */
if ((flags & O_CREAT) == 0 || path_element->class->write == NULL)
if ((flags & O_CREAT) == 0 || me->write == NULL)
return NULL;
name = g_path_get_dirname (q);
dir = vfs_s_find_inode (path_element->class, super, name, LINK_FOLLOW, FL_DIR);
dir = vfs_s_find_inode (me, super, name, LINK_FOLLOW, FL_DIR);
g_free (name);
if (dir == NULL)
return NULL;
name = g_path_get_basename (q);
ent = vfs_s_generate_entry (path_element->class, name, dir, 0755);
ent = vfs_s_generate_entry (me, name, dir, 0755);
ino = ent->ino;
vfs_s_insert_entry (path_element->class, dir, ent);
vfs_s_insert_entry (me, dir, ent);
if ((VFS_CLASS (s)->flags & VFSF_USETMP) != 0)
{
int tmp_handle;
vfs_path_t *tmp_vpath;
tmp_handle = vfs_mkstemps (&tmp_vpath, path_element->class->name, name);
tmp_handle = vfs_mkstemps (&tmp_vpath, me->name, name);
ino->localname = vfs_path_free (tmp_vpath, FALSE);
if (tmp_handle == -1)
{
@ -1360,7 +1360,7 @@ vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
if (S_ISDIR (ino->st.st_mode))
{
path_element->class->verrno = EISDIR;
me->verrno = EISDIR;
return NULL;
}
@ -1376,7 +1376,7 @@ vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
}
else
{
if (s->fh_open != NULL && s->fh_open (path_element->class, fh, flags, mode) != 0)
if (s->fh_open != NULL && s->fh_open (me, fh, flags, mode) != 0)
{
vfs_s_free_fh (s, fh);
return NULL;
@ -1389,13 +1389,13 @@ vfs_s_open (const vfs_path_t * vpath, int flags, mode_t mode)
if (fh->handle == -1)
{
vfs_s_free_fh (s, fh);
path_element->class->verrno = errno;
me->verrno = errno;
return NULL;
}
}
/* i.e. we had no open files and now we have one */
vfs_rmstamp (path_element->class, (vfsid) super);
vfs_rmstamp (me, (vfsid) super);
super->fd_usage++;
fh->ino->st.st_nlink++;
return fh;
@ -1573,13 +1573,13 @@ vfs_init_subclass (struct vfs_s_subclass *sub, const char *name, vfs_flags_t fla
vfsid
vfs_getid (const vfs_path_t * vpath)
{
const vfs_path_element_t *path_element;
const struct vfs_class *me;
path_element = vfs_path_get_by_index (vpath, -1);
if (!vfs_path_element_valid (path_element) || path_element->class->getid == NULL)
me = vfs_path_get_last_path_vfs (vpath);
if (me == NULL || me->getid == NULL)
return NULL;
return (*path_element->class->getid) (vpath);
return me->getid (vpath);
}
/* --------------------------------------------------------------------------------------------- */

23
lib/vfs/gc.c
View File

@ -186,12 +186,11 @@ void
vfs_stamp_path (const vfs_path_t * vpath)
{
vfsid id;
const vfs_path_element_t *path_element;
path_element = vfs_path_get_by_index (vpath, -1);
struct vfs_class *me;
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
id = vfs_getid (vpath);
vfs_addstamp (path_element->class, id);
vfs_addstamp (me, id);
}
/* --------------------------------------------------------------------------------------------- */
@ -206,7 +205,7 @@ vfs_stamp_create (struct vfs_class *vclass, vfsid id)
ev_vfs_stamp_create_t event_data = { vclass, id, FALSE };
const vfs_path_t *vpath;
const vfs_path_element_t *path_element;
struct vfs_class *me;
/* There are three directories we have to take care of: current_dir,
current_panel->cwd and other_panel->cwd. Although most of the time either
@ -217,12 +216,12 @@ vfs_stamp_create (struct vfs_class *vclass, vfsid id)
return;
vpath = vfs_get_raw_current_dir ();
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
nvfsid = vfs_getid (vpath);
vfs_rmstamp (path_element->class, nvfsid);
vfs_rmstamp (me, nvfsid);
if (!(id == NULL || (path_element->class == vclass && nvfsid == id)))
if (!(id == NULL || (me == vclass && nvfsid == id)))
{
mc_event_raise (MCEVENT_GROUP_CORE, "vfs_timestamp", (gpointer) & event_data);
@ -316,10 +315,12 @@ vfs_timeout_handler (void)
void
vfs_release_path (const vfs_path_t * vpath)
{
const vfs_path_element_t *path_element;
vfsid id;
struct vfs_class *me;
path_element = vfs_path_get_by_index (vpath, -1);
vfs_stamp_create (path_element->class, vfs_getid (vpath));
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
id = vfs_getid (vpath);
vfs_stamp_create (me, id);
}
/* --------------------------------------------------------------------------------------------- */

111
lib/vfs/interface.c
View File

@ -192,7 +192,7 @@ mc_open (const vfs_path_t * vpath, int flags, ...)
{
int result = -1;
mode_t mode = 0;
const vfs_path_element_t *path_element;
struct vfs_class *me;
if (vpath == NULL)
return (-1);
@ -210,17 +210,17 @@ mc_open (const vfs_path_t * vpath, int flags, ...)
va_end (ap);
}
path_element = vfs_path_get_by_index (vpath, -1);
if (vfs_path_element_valid (path_element) && path_element->class->open != NULL)
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
if (me != NULL && me->open != NULL)
{
void *info;
/* open must be supported */
info = path_element->class->open (vpath, flags, mode);
info = me->open (vpath, flags, mode);
if (info == NULL)
errno = vfs_ferrno (path_element->class);
errno = vfs_ferrno (me);
else
result = vfs_new_handle (path_element->class, info);
result = vfs_new_handle (me, info);
}
else
errno = ENOTSUP;
@ -236,18 +236,18 @@ mc_open (const vfs_path_t * vpath, int flags, ...)
int mc_##name inarg \
{ \
int result; \
const vfs_path_element_t *path_element; \
struct vfs_class *me; \
\
if (vpath == NULL) \
return (-1); \
\
path_element = vfs_path_get_by_index (vpath, -1); \
if (!vfs_path_element_valid (path_element)) \
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath)); \
if (me == NULL) \
return (-1); \
\
result = path_element->class->name != NULL ? path_element->class->name callarg : -1; \
result = me->name != NULL ? me->name callarg : -1; \
if (result == -1) \
errno = path_element->class->name != NULL ? vfs_ferrno (path_element->class) : ENOTSUP; \
errno = me->name != NULL ? vfs_ferrno (me) : ENOTSUP; \
return result; \
}
@ -273,19 +273,14 @@ mc_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
if (vpath1 != NULL && vpath2 != NULL)
{
const vfs_path_element_t *path_element;
struct vfs_class *me;
path_element = vfs_path_get_by_index (vpath2, -1);
if (vfs_path_element_valid (path_element))
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath2));
if (me != NULL)
{
result =
path_element->class->symlink != NULL ?
path_element->class->symlink (vpath1, vpath2) : -1;
result = me->symlink != NULL ? me->symlink (vpath1, vpath2) : -1;
if (result == -1)
errno =
path_element->class->symlink != NULL ?
vfs_ferrno (path_element->class) : ENOTSUP;
errno = me->symlink != NULL ? vfs_ferrno (me) : ENOTSUP;
}
}
return result;
@ -325,26 +320,23 @@ MC_HANDLEOP (int, fstat, (int handle, struct stat *buf), (fsinfo, buf))
int mc_##name (const vfs_path_t *vpath1, const vfs_path_t *vpath2) \
{ \
int result; \
const vfs_path_element_t *path_element1; \
const vfs_path_element_t *path_element2; \
struct vfs_class *me1, *me2; \
\
if (vpath1 == NULL || vpath2 == NULL) \
return (-1); \
\
path_element1 = vfs_path_get_by_index (vpath1, (-1)); \
path_element2 = vfs_path_get_by_index (vpath2, (-1)); \
me1 = VFS_CLASS (vfs_path_get_last_path_vfs (vpath1)); \
me2 = VFS_CLASS (vfs_path_get_last_path_vfs (vpath2)); \
\
if (!vfs_path_element_valid (path_element1) || !vfs_path_element_valid (path_element2) || \
path_element1->class != path_element2->class) \
if (me1 == NULL || me2 == NULL || me1 != me2) \
{ \
errno = EXDEV; \
return (-1); \
} \
\
result = path_element1->class->name != NULL \
? path_element1->class->name (vpath1, vpath2) : -1; \
result = me1->name != NULL ? me1->name (vpath1, vpath2) : -1; \
if (result == -1) \
errno = path_element1->class->name != NULL ? vfs_ferrno (path_element1->class) : ENOTSUP; \
errno = me1->name != NULL ? vfs_ferrno (me1) : ENOTSUP; \
return result; \
}
@ -372,16 +364,14 @@ int
mc_setctl (const vfs_path_t * vpath, int ctlop, void *arg)
{
int result = -1;
const vfs_path_element_t *path_element;
struct vfs_class *me;
if (vpath == NULL)
vfs_die ("You don't want to pass NULL to mc_setctl.");
path_element = vfs_path_get_by_index (vpath, -1);
if (vfs_path_element_valid (path_element))
result =
path_element->class->setctl != NULL ? path_element->class->setctl (vpath,
ctlop, arg) : 0;
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
if (me != NULL)
result = me->setctl != NULL ? me->setctl (vpath, ctlop, arg) : 0;
return result;
}
@ -545,17 +535,17 @@ mc_closedir (DIR * dirp)
int mc_##name (const vfs_path_t *vpath, struct stat *buf) \
{ \
int result = -1; \
const vfs_path_element_t *path_element; \
struct vfs_class *me; \
\
if (vpath == NULL) \
return (-1); \
\
path_element = vfs_path_get_by_index (vpath, -1); \
if (vfs_path_element_valid (path_element)) \
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath)); \
if (me != NULL) \
{ \
result = path_element->class->name ? path_element->class->name (vpath, buf) : -1; \
result = me->name ? me->name (vpath, buf) : -1; \
if (result == -1) \
errno = path_element->class->name ? vfs_ferrno (path_element->class) : ENOTSUP; \
errno = me->name ? vfs_ferrno (me) : ENOTSUP; \
} \
\
return result; \
@ -564,27 +554,24 @@ int mc_##name (const vfs_path_t *vpath, struct stat *buf) \
MC_STATOP (stat)
MC_STATOP (lstat)
/* *INDENT-ON* */
/* --------------------------------------------------------------------------------------------- */
vfs_path_t *
mc_getlocalcopy (const vfs_path_t * pathname_vpath)
{
vfs_path_t *result = NULL;
const vfs_path_element_t *path_element;
struct vfs_class *me;
if (pathname_vpath == NULL)
return NULL;
path_element = vfs_path_get_by_index (pathname_vpath, -1);
if (vfs_path_element_valid (path_element))
me = VFS_CLASS (vfs_path_get_last_path_vfs (pathname_vpath));
if (me != NULL)
{
result = path_element->class->getlocalcopy != NULL ?
path_element->class->getlocalcopy (pathname_vpath) :
mc_def_getlocalcopy (pathname_vpath);
result = me->getlocalcopy != NULL ?
me->getlocalcopy (pathname_vpath) : mc_def_getlocalcopy (pathname_vpath);
if (result == NULL)
errno = vfs_ferrno (path_element->class);
errno = vfs_ferrno (me);
}
return result;
}
@ -596,15 +583,15 @@ mc_ungetlocalcopy (const vfs_path_t * pathname_vpath, const vfs_path_t * local_v
gboolean has_changed)
{
int result = -1;
const vfs_path_element_t *path_element;
const struct vfs_class *me;
if (pathname_vpath == NULL)
return (-1);
path_element = vfs_path_get_by_index (pathname_vpath, -1);
if (vfs_path_element_valid (path_element))
result = path_element->class->ungetlocalcopy != NULL ?
path_element->class->ungetlocalcopy (pathname_vpath, local_vpath, has_changed) :
me = vfs_path_get_last_path_vfs (pathname_vpath);
if (me != NULL)
result = me->ungetlocalcopy != NULL ?
me->ungetlocalcopy (pathname_vpath, local_vpath, has_changed) :
mc_def_ungetlocalcopy (pathname_vpath, local_vpath, has_changed);
return result;
@ -626,6 +613,7 @@ mc_chdir (const vfs_path_t * vpath)
struct vfs_class *old_vfs;
vfsid old_vfsid;
int result;
struct vfs_class *me;
const vfs_path_element_t *path_element;
vfs_path_t *cd_vpath;
@ -640,23 +628,23 @@ mc_chdir (const vfs_path_t * vpath)
else
cd_vpath = vfs_path_clone (vpath);
path_element = vfs_path_get_by_index (cd_vpath, -1);
if (!vfs_path_element_valid (path_element))
me = VFS_CLASS (vfs_path_get_last_path_vfs (cd_vpath));
if (me == NULL)
{
errno = EINVAL;
goto error_end;
}
if (path_element->class->chdir == NULL)
if (me->chdir == NULL)
{
errno = ENOTSUP;
goto error_end;
}
result = path_element->class->chdir (cd_vpath);
result = me->chdir (cd_vpath);
if (result == -1)
{
errno = vfs_ferrno (path_element->class);
errno = vfs_ferrno (me);
goto error_end;
}
@ -665,8 +653,7 @@ mc_chdir (const vfs_path_t * vpath)
/* Actually change directory */
vfs_set_raw_current_dir (cd_vpath);
current_vfs = path_element->class;
current_vfs = me;
/* This function uses the new current_dir implicitly */
vfs_stamp_create (old_vfs, old_vfsid);

12
lib/vfs/vfs.c
View File

@ -481,8 +481,6 @@ vfs_init (void)
void
vfs_setup_work_dir (void)
{
const vfs_path_element_t *path_element;
vfs_setup_cwd ();
/* FIXME: is we really need for this check? */
@ -491,8 +489,7 @@ vfs_setup_work_dir (void)
vfs_die ("Current dir too long.\n");
*/
path_element = vfs_path_get_by_index (current_path, -1);
current_vfs = path_element->class;
current_vfs = VFS_CLASS (vfs_path_get_last_path_vfs (current_path));
}
/* --------------------------------------------------------------------------------------------- */
@ -640,7 +637,7 @@ vfs_setup_cwd (void)
{
char *current_dir;
vfs_path_t *tmp_vpath;
const vfs_path_element_t *path_element;
const struct vfs_class *me;
if (vfs_get_raw_current_dir () == NULL)
{
@ -660,9 +657,8 @@ vfs_setup_cwd (void)
}
}
path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
if ((path_element->class->flags & VFSF_LOCAL) != 0)
me = vfs_path_get_last_path_vfs (vfs_get_raw_current_dir ());
if ((me->flags & VFSF_LOCAL) != 0)
{
current_dir = g_get_current_dir ();
tmp_vpath = vfs_path_from_str (current_dir);

4
src/filemanager/file.c
View File

@ -2919,7 +2919,7 @@ copy_dir_dir (file_op_total_context_t * tctx, file_op_context_t * ctx, const cha
}
lp = g_new0 (struct link, 1);
lp->vfs = vfs_path_get_by_index (src_vpath, -1)->class;
lp->vfs = vfs_path_get_last_path_vfs (src_vpath);
lp->ino = src_stat.st_ino;
lp->dev = src_stat.st_dev;
parent_dirs = g_slist_prepend (parent_dirs, lp);
@ -2995,7 +2995,7 @@ copy_dir_dir (file_op_total_context_t * tctx, file_op_context_t * ctx, const cha
lp = g_new0 (struct link, 1);
mc_stat (dst_vpath, &dst_stat);
lp->vfs = vfs_path_get_by_index (dst_vpath, -1)->class;
lp->vfs = vfs_path_get_last_path_vfs (dst_vpath);
lp->ino = dst_stat.st_ino;
lp->dev = dst_stat.st_dev;
dest_dirs = g_slist_prepend (dest_dirs, lp);

7
src/filemanager/filemanager.c
View File

@ -465,11 +465,10 @@ check_panel_timestamp (const WPanel * panel, panel_view_mode_t mode, struct vfs_
{
if (mode == view_listing)
{
const vfs_path_element_t *path_element;
const struct vfs_class *me;
path_element = vfs_path_get_by_index (panel->cwd_vpath, -1);
if (path_element->class != vclass)
me = vfs_path_get_last_path_vfs (panel->cwd_vpath);
if (me != vclass)
return FALSE;
if (vfs_getid (panel->cwd_vpath) != id)

23
src/vfs/extfs/extfs.c
View File

@ -1279,10 +1279,7 @@ extfs_readlink (const vfs_path_t * vpath, char *buf, size_t size)
goto cleanup;
if (!S_ISLNK (entry->ino->st.st_mode))
{
const vfs_path_element_t *path_element;
path_element = vfs_path_get_by_index (vpath, -1);
path_element->class->verrno = EINVAL;
VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = EINVAL;
goto cleanup;
}
len = strlen (entry->ino->linkname);
@ -1348,10 +1345,7 @@ extfs_unlink (const vfs_path_t * vpath)
goto cleanup;
if (S_ISDIR (entry->ino->st.st_mode))
{
const vfs_path_element_t *path_element;
path_element = vfs_path_get_by_index (vpath, -1);
path_element->class->verrno = EISDIR;
VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = EISDIR;
goto cleanup;
}
if (extfs_cmd (" rm ", archive, entry, ""))
@ -1374,18 +1368,18 @@ extfs_mkdir (const vfs_path_t * vpath, mode_t mode)
const char *q;
struct vfs_s_entry *entry;
int result = -1;
const vfs_path_element_t *path_element;
struct vfs_class *me;
(void) mode;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
q = extfs_get_path (vpath, &archive, FL_NONE);
if (q == NULL)
goto cleanup;
entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_NONE);
if (entry != NULL)
{
path_element->class->verrno = EEXIST;
me->verrno = EEXIST;
goto cleanup;
}
entry = extfs_find_entry (VFS_SUPER (archive)->root, q, FL_MKDIR);
@ -1396,7 +1390,7 @@ extfs_mkdir (const vfs_path_t * vpath, mode_t mode)
goto cleanup;
if (!S_ISDIR (entry->ino->st.st_mode))
{
path_element->class->verrno = ENOTDIR;
me->verrno = ENOTDIR;
goto cleanup;
}
@ -1432,10 +1426,7 @@ extfs_rmdir (const vfs_path_t * vpath)
goto cleanup;
if (!S_ISDIR (entry->ino->st.st_mode))
{
const vfs_path_element_t *path_element;
path_element = vfs_path_get_by_index (vpath, -1);
path_element->class->verrno = ENOTDIR;
VFS_CLASS (vfs_path_get_last_path_vfs (vpath))->verrno = ENOTDIR;
goto cleanup;
}

82
src/vfs/fish/fish.c
View File

@ -1255,11 +1255,9 @@ fish_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
const char *crpath1, *crpath2;
char *rpath1, *rpath2;
struct vfs_s_super *super, *super2;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath1, -1);
crpath1 = vfs_s_get_path (vpath1, &super, 0);
if (crpath1 == NULL)
return -1;
@ -1271,8 +1269,10 @@ fish_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
rpath1 = strutils_shell_escape (crpath1);
rpath2 = strutils_shell_escape (crpath2);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath1));
ret =
fish_send_command (path_element->class, super2, OPT_FLUSH, FISH_SUPER (super)->scr_mv,
fish_send_command (me, super2, OPT_FLUSH, FISH_SUPER (super)->scr_mv,
"FISH_FILEFROM=%s FISH_FILETO=%s;\n", rpath1, rpath2);
g_free (rpath1);
@ -1289,11 +1289,9 @@ fish_link (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
const char *crpath1, *crpath2;
char *rpath1, *rpath2;
struct vfs_s_super *super, *super2;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath1, -1);
crpath1 = vfs_s_get_path (vpath1, &super, 0);
if (crpath1 == NULL)
return -1;
@ -1305,8 +1303,10 @@ fish_link (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
rpath1 = strutils_shell_escape (crpath1);
rpath2 = strutils_shell_escape (crpath2);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath1));
ret =
fish_send_command (path_element->class, super2, OPT_FLUSH, FISH_SUPER (super)->scr_hardlink,
fish_send_command (me, super2, OPT_FLUSH, FISH_SUPER (super)->scr_hardlink,
"FISH_FILEFROM=%s FISH_FILETO=%s;\n", rpath1, rpath2);
g_free (rpath1);
@ -1324,11 +1324,9 @@ fish_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath2, -1);
crpath = vfs_s_get_path (vpath2, &super, 0);
if (crpath == NULL)
return -1;
@ -1336,8 +1334,10 @@ fish_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
rpath = strutils_shell_escape (crpath);
qsetto = strutils_shell_escape (vfs_path_get_last_path_str (vpath1));
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath2));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_ln,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_ln,
"FISH_FILEFROM=%s FISH_FILETO=%s;\n", qsetto, rpath);
g_free (qsetto);
@ -1390,19 +1390,19 @@ fish_chmod (const vfs_path_t * vpath, mode_t mode)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_chmod,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_chmod,
"FISH_FILENAME=%s FISH_FILEMODE=%4.4o;\n", rpath,
(unsigned int) (mode & 07777));
@ -1422,7 +1422,7 @@ fish_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
pw = getpwuid (owner);
@ -1436,17 +1436,17 @@ fish_chown (const vfs_path_t * vpath, uid_t owner, gid_t group)
sowner = pw->pw_name;
sgroup = gr->gr_name;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
/* FIXME: what should we report if chgrp succeeds but chown fails? */
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_chown,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_chown,
"FISH_FILENAME=%s FISH_FILEOWNER=%s FISH_FILEGROUP=%s;\n", rpath, sowner,
sgroup);
@ -1496,11 +1496,9 @@ fish_utime (const vfs_path_t * vpath, mc_timesbuf_t * times)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
@ -1525,7 +1523,9 @@ fish_utime (const vfs_path_t * vpath, mc_timesbuf_t * times)
gmt->tm_year + 1900, gmt->tm_mon + 1, gmt->tm_mday,
gmt->tm_hour, gmt->tm_min, gmt->tm_sec, mtime_nsec);
ret = fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_utime,
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret = fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_utime,
"FISH_FILENAME=%s FISH_FILEATIME=%ld FISH_FILEMTIME=%ld "
"FISH_TOUCHATIME=%s FISH_TOUCHMTIME=%s FISH_TOUCHATIME_W_NSEC=\"%s\" "
"FISH_TOUCHMTIME_W_NSEC=\"%s\";\n", rpath, (long) atime, (long) mtime,
@ -1544,19 +1544,19 @@ fish_unlink (const vfs_path_t * vpath)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_unlink,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_unlink,
"FISH_FILENAME=%s;\n", rpath);
g_free (rpath);
@ -1572,19 +1572,19 @@ fish_exists (const vfs_path_t * vpath)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_exists,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_exists,
"FISH_FILENAME=%s;\n", rpath);
g_free (rpath);
@ -1600,21 +1600,21 @@ fish_mkdir (const vfs_path_t * vpath, mode_t mode)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
(void) mode;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_mkdir,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_mkdir,
"FISH_FILENAME=%s;\n", rpath);
g_free (rpath);
@ -1623,7 +1623,7 @@ fish_mkdir (const vfs_path_t * vpath, mode_t mode)
if (fish_exists (vpath) == 0)
{
path_element->class->verrno = EACCES;
me->verrno = EACCES;
return -1;
}
return 0;
@ -1637,19 +1637,19 @@ fish_rmdir (const vfs_path_t * vpath)
const char *crpath;
char *rpath;
struct vfs_s_super *super;
const vfs_path_element_t *path_element;
struct vfs_class *me;
int ret;
path_element = vfs_path_get_by_index (vpath, -1);
crpath = vfs_s_get_path (vpath, &super, 0);
if (crpath == NULL)
return -1;
rpath = strutils_shell_escape (crpath);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
ret =
fish_send_command (path_element->class, super, OPT_FLUSH, FISH_SUPER (super)->scr_rmdir,
fish_send_command (me, super, OPT_FLUSH, FISH_SUPER (super)->scr_rmdir,
"FISH_FILENAME=%s;\n", rpath);
g_free (rpath);

12
src/vfs/ftpfs/ftpfs.c
View File

@ -2121,28 +2121,28 @@ ftpfs_send_command (const vfs_path_t * vpath, const char *cmd, int flags)
char *p;
struct vfs_s_super *super;
int r;
const vfs_path_element_t *path_element;
struct vfs_class *me;
gboolean flush_directory_cache = (flags & OPT_FLUSH) != 0;
path_element = vfs_path_get_by_index (vpath, -1);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
rpath = vfs_s_get_path (vpath, &super, 0);
if (rpath == NULL)
return (-1);
p = ftpfs_translate_path (path_element->class, super, rpath);
r = ftpfs_command (path_element->class, super, WAIT_REPLY, cmd, p);
p = ftpfs_translate_path (me, super, rpath);
r = ftpfs_command (me, super, WAIT_REPLY, cmd, p);
g_free (p);
vfs_stamp_create (vfs_ftpfs_ops, super);
if ((flags & OPT_IGNORE_ERROR) != 0)
r = COMPLETE;
if (r != COMPLETE)
{
path_element->class->verrno = EPERM;
me->verrno = EPERM;
return (-1);
}
if (flush_directory_cache)
vfs_s_invalidate (path_element->class, super);
vfs_s_invalidate (me, super);
return 0;
}

1
src/vfs/sftpfs/internal.c
View File

@ -596,7 +596,6 @@ sftpfs_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2, GError ** m
tmp_path_len = ctmp_path->len;
path1 = vfs_path_get_last_path_str (vpath1);
fixfname = sftpfs_fix_filename (path1);
do

20
src/vfs/sftpfs/sftpfs.c
View File

@ -107,23 +107,23 @@ static void *
sftpfs_cb_open (const vfs_path_t * vpath, int flags, mode_t mode)
{
vfs_file_handler_t *fh;
const vfs_path_element_t *path_element;
struct vfs_class *me;
struct vfs_s_super *super;
const char *path_super;
struct vfs_s_inode *path_inode;
GError *mcerror = NULL;
gboolean is_changed = FALSE;
path_element = vfs_path_get_by_index (vpath, -1);
path_super = vfs_s_get_path (vpath, &super, 0);
if (path_super == NULL)
return NULL;
path_inode = vfs_s_find_inode (path_element->class, super, path_super, LINK_FOLLOW, FL_NONE);
me = VFS_CLASS (vfs_path_get_last_path_vfs (vpath));
path_inode = vfs_s_find_inode (me, super, path_super, LINK_FOLLOW, FL_NONE);
if (path_inode != NULL && ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)))
{
path_element->class->verrno = EEXIST;
me->verrno = EEXIST;
return NULL;
}
@ -134,22 +134,22 @@ sftpfs_cb_open (const vfs_path_t * vpath, int flags, mode_t mode)
struct vfs_s_inode *dir;
name = g_path_get_dirname (path_super);
dir = vfs_s_find_inode (path_element->class, super, name, LINK_FOLLOW, FL_DIR);
dir = vfs_s_find_inode (me, super, name, LINK_FOLLOW, FL_DIR);
g_free (name);
if (dir == NULL)
return NULL;
name = g_path_get_basename (path_super);
ent = vfs_s_generate_entry (path_element->class, name, dir, 0755);
ent = vfs_s_generate_entry (me, name, dir, 0755);
g_free (name);
path_inode = ent->ino;
vfs_s_insert_entry (path_element->class, dir, ent);
vfs_s_insert_entry (me, dir, ent);
is_changed = TRUE;
}
if (S_ISDIR (path_inode->st.st_mode))
{
path_element->class->verrno = EISDIR;
me->verrno = EISDIR;
return NULL;
}
@ -162,7 +162,7 @@ sftpfs_cb_open (const vfs_path_t * vpath, int flags, mode_t mode)
return NULL;
}
vfs_rmstamp (path_element->class, (vfsid) super);
vfs_rmstamp (me, (vfsid) super);
super->fd_usage++;
fh->ino->st.st_nlink++;
return fh;

8
src/vfs/undelfs/undelfs.c
View File

@ -333,9 +333,9 @@ static void *
undelfs_opendir (const vfs_path_t * vpath)
{
char *file, *f = NULL;
const vfs_path_element_t *path_element;
const char *class_name;
path_element = vfs_path_get_by_index (vpath, -1);
class_name = vfs_path_get_last_path_vfs (vpath)->name;
undelfs_get_path (vpath, &file, &f);
if (file == NULL)
{
@ -379,10 +379,10 @@ undelfs_opendir (const vfs_path_t * vpath)
/* Now load the deleted information */
if (!undelfs_loaddel ())
goto quit_opendir;
vfs_print_message (_("%s: done."), path_element->class->name);
vfs_print_message (_("%s: done."), class_name);
return fs;
quit_opendir:
vfs_print_message (_("%s: failure"), path_element->class->name);
vfs_print_message (_("%s: failure"), class_name);
ext2fs_close (fs);
fs = NULL;
return 0;