ssize_t
sftpfs_write_file (vfs_file_handler_t * file_handler, const char *buffer, size_t count,
GError ** mcerror)
{
ssize_t rc;
sftpfs_file_handler_data_t *file_handler_data;
sftpfs_super_data_t *super_data;
mc_return_val_if_error (mcerror, -1);
file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
do
{
rc = libssh2_sftp_write (file_handler_data->handle, buffer, count);
if (rc >= 0)
break;
if (rc != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, rc, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (rc == LIBSSH2_ERROR_EAGAIN);
return rc;
}
int
sftpfs_fstat (void *data, struct stat *buf, GError ** mcerror)
{
int res;
LIBSSH2_SFTP_ATTRIBUTES attrs;
vfs_file_handler_t *fh = (vfs_file_handler_t *) data;
sftpfs_file_handler_data_t *sftpfs_fh = fh->data;
struct vfs_s_super *super = fh->ino->super;
sftpfs_super_data_t *super_data = (sftpfs_super_data_t *) super->data;
mc_return_val_if_error (mcerror, -1);
if (sftpfs_fh->handle == NULL)
return -1;
do
{
res = libssh2_sftp_fstat_ex (sftpfs_fh->handle, &attrs, 0);
if (res >= 0)
break;
if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (res == LIBSSH2_ERROR_EAGAIN);
if ((attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID) != 0)
{
buf->st_uid = attrs.uid;
buf->st_gid = attrs.gid;
}
if ((attrs.flags & LIBSSH2_SFTP_ATTR_ACMODTIME) != 0)
{
buf->st_atime = attrs.atime;
buf->st_mtime = attrs.mtime;
buf->st_ctime = attrs.mtime;
}
if ((attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) != 0)
buf->st_size = attrs.filesize;
if ((attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) != 0)
buf->st_mode = attrs.permissions;
return 0;
}
int
sftpfs_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2, GError ** mcerror)
{
struct vfs_s_super *super;
sftpfs_super_data_t *super_data;
const vfs_path_element_t *path_element1;
const vfs_path_element_t *path_element2;
char *tmp_path;
int res;
mc_return_val_if_error (mcerror, -1);
path_element2 = vfs_path_get_by_index (vpath2, -1);
if (vfs_s_get_path (vpath2, &super, 0) == NULL)
return -1;
if (super == NULL)
return -1;
super_data = (sftpfs_super_data_t *) super->data;
if (super_data->sftp_session == NULL)
return -1;
tmp_path = g_strdup_printf ("%c%s", PATH_SEP, path_element2->path);
path_element1 = vfs_path_get_by_index (vpath1, -1);
do
{
const char *fixfname;
fixfname = sftpfs_fix_filename (path_element1->path);
res =
libssh2_sftp_symlink_ex (super_data->sftp_session,
fixfname,
sftpfs_filename_buffer->len, tmp_path, strlen (tmp_path),
LIBSSH2_SFTP_SYMLINK);
if (res >= 0)
break;
if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
g_free (tmp_path);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
if (mcerror != NULL && *mcerror != NULL)
{
g_free (tmp_path);
return -1;
}
}
while (res == LIBSSH2_ERROR_EAGAIN);
g_free (tmp_path);
return 0;
}
int
sftpfs_waitsocket (sftpfs_super_data_t * super_data, GError ** mcerror)
{
struct timeval timeout = { 10, 0 };
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
mc_return_val_if_error (mcerror, -1);
FD_ZERO (&fd);
FD_SET (super_data->socket_handle, &fd);
/* now make sure we wait in the correct direction */
dir = libssh2_session_block_directions (super_data->session);
if ((dir & LIBSSH2_SESSION_BLOCK_INBOUND) != 0)
readfd = &fd;
if ((dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0)
writefd = &fd;
return select (super_data->socket_handle + 1, readfd, writefd, NULL, &timeout);
}
int
sftpfs_unlink (const vfs_path_t * vpath, GError ** mcerror)
{
struct vfs_s_super *super;
sftpfs_super_data_t *super_data;
int res;
const vfs_path_element_t *path_element;
mc_return_val_if_error (mcerror, -1);
path_element = vfs_path_get_by_index (vpath, -1);
if (vfs_s_get_path (vpath, &super, 0) == NULL)
return -1;
if (super == NULL)
return -1;
super_data = (sftpfs_super_data_t *) super->data;
if (super_data->sftp_session == NULL)
return -1;
do
{
const char *fixfname;
fixfname = sftpfs_fix_filename (path_element->path);
res =
libssh2_sftp_unlink_ex (super_data->sftp_session, fixfname,
sftpfs_filename_buffer->len);
if (res >= 0)
break;
if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (res == LIBSSH2_ERROR_EAGAIN);
return res;
}
gboolean
mc_config_save_file (mc_config_t * mc_config, GError ** mcerror)
{
mc_return_val_if_error (mcerror, FALSE);
if (mc_config == NULL || mc_config->ini_path == NULL)
return FALSE;
return mc_config_new_or_override_file (mc_config, mc_config->ini_path, mcerror);
}
gboolean
mc_config_save_to_file (mc_config_t * mc_config, const gchar * ini_path, GError ** mcerror)
{
mc_return_val_if_error (mcerror, FALSE);
if (mc_config == NULL)
return FALSE;
return mc_config_new_or_override_file (mc_config, ini_path, mcerror);
}
off_t
sftpfs_lseek (vfs_file_handler_t * file_handler, off_t offset, int whence, GError ** mcerror)
{
sftpfs_file_handler_data_t *file_handler_data;
mc_return_val_if_error (mcerror, 0);
switch (whence)
{
case SEEK_SET:
/* Need reopen file because:
"You MUST NOT seek during writing or reading a file with SFTP, as the internals use
outstanding packets and changing the "file position" during transit will results in
badness." */
if (file_handler->pos > offset || offset == 0)
{
sftpfs_reopen (file_handler, mcerror);
mc_return_val_if_error (mcerror, 0);
}
file_handler->pos = offset;
break;
case SEEK_CUR:
file_handler->pos += offset;
break;
case SEEK_END:
if (file_handler->pos > file_handler->ino->st.st_size - offset)
{
sftpfs_reopen (file_handler, mcerror);
mc_return_val_if_error (mcerror, 0);
}
file_handler->pos = file_handler->ino->st.st_size - offset;
break;
}
file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
libssh2_sftp_seek64 (file_handler_data->handle, file_handler->pos);
file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
return file_handler->pos;
}
ssize_t
sftpfs_read_file (vfs_file_handler_t * file_handler, char *buffer, size_t count, GError ** mcerror)
{
ssize_t rc;
sftpfs_file_handler_data_t *file_handler_data;
sftpfs_super_data_t *super_data;
mc_return_val_if_error (mcerror, -1);
if (file_handler == NULL || file_handler->data == NULL)
{
mc_propagate_error (mcerror, -1, "%s",
_("sftp: No file handler data present for reading file"));
return -1;
}
file_handler_data = file_handler->data;
super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
do
{
rc = libssh2_sftp_read (file_handler_data->handle, buffer, count);
if (rc >= 0)
break;
if (rc != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, rc, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (rc == LIBSSH2_ERROR_EAGAIN);
file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
return rc;
}
static gboolean
parse_mc_v_argument (const gchar * option_name, const gchar * value, gpointer data,
GError ** mcerror)
{
(void) option_name;
(void) value;
(void) data;
mc_return_val_if_error (mcerror, FALSE);
mc_global.mc_run_mode = MC_RUN_VIEWER;
return TRUE;
}
static gboolean
mc_config_new_or_override_file (mc_config_t * mc_config, const gchar * ini_path, GError ** mcerror)
{
gchar *data, *written_data;
gsize len, total_written;
gboolean ret;
int fd;
ssize_t cur_written;
vfs_path_t *ini_vpath;
mc_return_val_if_error (mcerror, FALSE);
data = g_key_file_to_data (mc_config->handle, &len, NULL);
if (!exist_file (ini_path))
{
ret = g_file_set_contents (ini_path, data, len, mcerror);
g_free (data);
return ret;
}
mc_util_make_backup_if_possible (ini_path, "~");
ini_vpath = vfs_path_from_str (ini_path);
fd = mc_open (ini_vpath, O_WRONLY | O_TRUNC, 0);
vfs_path_free (ini_vpath);
if (fd == -1)
{
mc_propagate_error (mcerror, 0, "%s", unix_error_string (errno));
g_free (data);
return FALSE;
}
for (written_data = data, total_written = len;
(cur_written = mc_write (fd, (const void *) written_data, total_written)) > 0;
written_data += cur_written, total_written -= cur_written)
;
mc_close (fd);
g_free (data);
if (cur_written == -1)
{
mc_util_restore_from_backup_if_possible (ini_path, "~");
mc_propagate_error (mcerror, 0, "%s", unix_error_string (errno));
return FALSE;
}
mc_util_unlink_backup_if_possible (ini_path, "~");
return TRUE;
}
gboolean
mc_skin_init (const gchar * skin_override, GError ** mcerror)
{
gboolean is_good_init = TRUE;
mc_return_val_if_error (mcerror, FALSE);
mc_skin__default.have_256_colors = FALSE;
mc_skin__default.name =
skin_override != NULL ? g_strdup (skin_override) : mc_skin_get_default_name ();
mc_skin__default.colors = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, mc_skin_hash_destroy_value);
if (!mc_skin_ini_file_load (&mc_skin__default))
{
mc_propagate_error (mcerror, 0,
_("Unable to load '%s' skin.\nDefault skin has been loaded"),
mc_skin__default.name);
mc_skin_try_to_load_default ();
is_good_init = FALSE;
}
mc_skin_colors_old_configure (&mc_skin__default);
if (!mc_skin_ini_file_parse (&mc_skin__default))
{
mc_propagate_error (mcerror, 0,
_("Unable to parse '%s' skin.\nDefault skin has been loaded"),
mc_skin__default.name);
mc_skin_try_to_load_default ();
mc_skin_colors_old_configure (&mc_skin__default);
(void) mc_skin_ini_file_parse (&mc_skin__default);
is_good_init = FALSE;
}
if (is_good_init && !tty_use_256colors () && mc_skin__default.have_256_colors)
{
mc_propagate_error (mcerror, 0,
_
("Unable to use '%s' skin with 256 colors support\non non-256 colors terminal.\nDefault skin has been loaded"),
mc_skin__default.name);
mc_skin_try_to_load_default ();
mc_skin_colors_old_configure (&mc_skin__default);
(void) mc_skin_ini_file_parse (&mc_skin__default);
is_good_init = FALSE;
}
mc_skin_is_init = TRUE;
return is_good_init;
}
gboolean
mc_event_deinit (GError ** mcerror)
{
mc_return_val_if_error (mcerror, FALSE);
if (mc_event_grouplist == NULL)
{
mc_propagate_error (mcerror, 3, "%s", _("Event system not initialized"));
return FALSE;
}
g_tree_destroy (mc_event_grouplist);
mc_event_grouplist = NULL;
return TRUE;
}
int
sftpfs_close_file (vfs_file_handler_t * file_handler, GError ** mcerror)
{
sftpfs_file_handler_data_t *file_handler_data;
mc_return_val_if_error (mcerror, -1);
file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
if (file_handler_data == NULL)
return -1;
libssh2_sftp_close (file_handler_data->handle);
g_free (file_handler_data);
return 0;
}
gboolean
mc_event_mass_add (event_init_t * events, GError ** mcerror)
{
size_t array_index;
mc_return_val_if_error (mcerror, FALSE);
for (array_index = 0; events[array_index].event_group_name != NULL; array_index++)
{
if (!mc_event_add (events[array_index].event_group_name,
events[array_index].event_name,
events[array_index].cb, events[array_index].init_data, mcerror))
{
return FALSE;
}
}
return TRUE;
}
gboolean
mc_event_init (GError ** mcerror)
{
mc_return_val_if_error (mcerror, FALSE);
if (mc_event_grouplist != NULL)
{
mc_propagate_error (mcerror, 1, "%s", _("Event system already initialized"));
return FALSE;
}
mc_event_grouplist =
g_tree_new_full ((GCompareDataFunc) g_ascii_strcasecmp,
NULL, (GDestroyNotify) g_free, (GDestroyNotify) g_tree_destroy);
if (mc_event_grouplist == NULL)
{
mc_propagate_error (mcerror, 2, "%s", _("Failed to initialize event system"));
return FALSE;
}
return TRUE;
}
gboolean
mc_setup_by_args (int argc, char **argv, GError ** mcerror)
{
const char *base;
char *tmp;
mc_return_val_if_error (mcerror, FALSE);
if (mc_args__force_colors)
mc_global.tty.disable_colors = FALSE;
#ifdef ENABLE_SUBSHELL
if (mc_args__nouse_subshell)
mc_global.tty.use_subshell = FALSE;
#endif /* ENABLE_SUBSHELL */
#ifdef ENABLE_VFS_SMB
if (mc_args__debug_level != 0)
smbfs_set_debug (mc_args__debug_level);
#endif /* ENABLE_VFS_SMB */
if (mc_args__netfs_logfile != NULL)
{
vfs_path_t *vpath;
#ifdef ENABLE_VFS_FTP
vpath = vfs_path_from_str ("ftp://");
mc_setctl (vpath, VFS_SETCTL_LOGFILE, (void *) mc_args__netfs_logfile);
vfs_path_free (vpath);
#endif /* ENABLE_VFS_FTP */
#ifdef ENABLE_VFS_SMB
vpath = vfs_path_from_str ("smb://");
mc_setctl (vpath, VFS_SETCTL_LOGFILE, (void *) mc_args__netfs_logfile);
vfs_path_free (vpath);
#endif /* ENABLE_VFS_SMB */
(void) vpath;
}
base = x_basename (argv[0]);
tmp = (argc > 0) ? argv[1] : NULL;
if (strncmp (base, "mce", 3) == 0 || strcmp (base, "vi") == 0)
{
/* mce* or vi is link to mc */
mc_global.mc_run_mode = MC_RUN_EDITOR;
}
else if (strncmp (base, "mcv", 3) == 0 || strcmp (base, "view") == 0)
{
/* mcv* or view is link to mc */
mc_global.mc_run_mode = MC_RUN_VIEWER;
}
#ifdef USE_DIFF_VIEW
else if (strncmp (base, "mcd", 3) == 0 || strcmp (base, "diff") == 0)
{
/* mcd* or diff is link to mc */
mc_global.mc_run_mode = MC_RUN_DIFFVIEWER;
}
#endif /* USE_DIFF_VIEW */
switch (mc_global.mc_run_mode)
{
case MC_RUN_EDITOR:
mc_run_param0 = parse_mcedit_arguments (argc - 1, &argv[1]);
break;
case MC_RUN_VIEWER:
if (tmp == NULL)
{
mc_propagate_error (mcerror, 0, "%s\n", _("No arguments given to the viewer."));
return FALSE;
}
mc_run_param0 = g_strdup (tmp);
break;
#ifdef USE_DIFF_VIEW
case MC_RUN_DIFFVIEWER:
if (argc < 3)
{
mc_propagate_error (mcerror, 0, "%s\n",
_("Two files are required to envoke the diffviewer."));
return FALSE;
}
/* fallthrough */
#endif /* USE_DIFF_VIEW */
case MC_RUN_FULL:
default:
/* set the current dir and the other dir for filemanager,
or two files for diff viewer */
if (tmp != NULL)
{
mc_run_param0 = g_strdup (tmp);
tmp = (argc > 1) ? argv[2] : NULL;
if (tmp != NULL)
mc_run_param1 = g_strdup (tmp);
}
break;
}
return TRUE;
}
gboolean
mc_args_parse (int *argc, char ***argv, const char *translation_domain, GError ** mcerror)
{
const gchar *_system_codepage;
gboolean ok = TRUE;
mc_return_val_if_error (mcerror, FALSE);
_system_codepage = str_detect_termencoding ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", "UTF-8");
#endif
context = g_option_context_new (mc_args_add_usage_info ());
g_option_context_set_ignore_unknown_options (context, FALSE);
mc_args_add_extended_info_to_help ();
main_group = g_option_group_new ("main", _("Main options"), _("Main options"), NULL, NULL);
g_option_group_add_entries (main_group, argument_main_table);
g_option_context_set_main_group (context, main_group);
g_option_group_set_translation_domain (main_group, translation_domain);
terminal_group = g_option_group_new ("terminal", _("Terminal options"),
_("Terminal options"), NULL, NULL);
g_option_group_add_entries (terminal_group, argument_terminal_table);
g_option_context_add_group (context, terminal_group);
g_option_group_set_translation_domain (terminal_group, translation_domain);
color_group = mc_args_new_color_group ();
g_option_group_add_entries (color_group, argument_color_table);
g_option_context_add_group (context, color_group);
g_option_group_set_translation_domain (color_group, translation_domain);
if (!g_option_context_parse (context, argc, argv, mcerror))
{
if (*mcerror == NULL)
mc_propagate_error (mcerror, 0, "%s\n", _("Arguments parse error!"));
else
{
gchar *help_str;
help_str = g_option_context_get_help (context, TRUE, NULL);
if (str_isutf8 (_system_codepage))
mc_replace_error (mcerror, (*mcerror)->code, "%s\n\n%s\n", (*mcerror)->message,
help_str);
else
{
gchar *full_help_str;
full_help_str =
mc_args__convert_help_to_syscharset (_system_codepage, (*mcerror)->message,
help_str);
mc_replace_error (mcerror, (*mcerror)->code, "%s", full_help_str);
g_free (full_help_str);
}
g_free (help_str);
}
ok = FALSE;
}
g_option_context_free (context);
mc_args_clean_temp_help_strings ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", _system_codepage);
#endif
return ok;
}
gboolean
sftpfs_open_file (vfs_file_handler_t * file_handler, int flags, mode_t mode, GError ** mcerror)
{
unsigned long sftp_open_flags = 0;
int sftp_open_mode = 0;
gboolean do_append = FALSE;
sftpfs_file_handler_data_t *file_handler_data;
sftpfs_super_data_t *super_data;
char *name;
(void) mode;
mc_return_val_if_error (mcerror, FALSE);
name = vfs_s_fullpath (&sftpfs_class, file_handler->ino);
if (name == NULL)
return FALSE;
super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
file_handler_data = g_new0 (sftpfs_file_handler_data_t, 1);
if ((flags & O_CREAT) != 0 || (flags & O_WRONLY) != 0)
{
sftp_open_flags = (flags & O_WRONLY) != 0 ? LIBSSH2_FXF_WRITE : 0;
sftp_open_flags |= (flags & O_CREAT) != 0 ? LIBSSH2_FXF_CREAT : 0;
if ((flags & O_APPEND) != 0)
{
sftp_open_flags |= LIBSSH2_FXF_APPEND;
do_append = TRUE;
}
sftp_open_flags |= (flags & O_TRUNC) != 0 ? LIBSSH2_FXF_TRUNC : 0;
sftp_open_mode = LIBSSH2_SFTP_S_IRUSR |
LIBSSH2_SFTP_S_IWUSR | LIBSSH2_SFTP_S_IRGRP | LIBSSH2_SFTP_S_IROTH;
}
else
sftp_open_flags = LIBSSH2_FXF_READ;
while (TRUE)
{
int libssh_errno;
file_handler_data->handle =
libssh2_sftp_open (super_data->sftp_session, sftpfs_fix_filename (name),
sftp_open_flags, sftp_open_mode);
if (file_handler_data->handle != NULL)
break;
libssh_errno = libssh2_session_last_errno (super_data->session);
if (libssh_errno != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, libssh_errno, mcerror);
g_free (name);
g_free (file_handler_data);
return FALSE;
}
}
g_free (name);
file_handler_data->flags = flags;
file_handler_data->mode = mode;
file_handler->data = file_handler_data;
if (do_append)
{
struct stat file_info;
if (sftpfs_fstat (file_handler, &file_info, mcerror) == 0)
libssh2_sftp_seek64 (file_handler_data->handle, file_info.st_size);
}
return TRUE;
}
int
sftpfs_stat (const vfs_path_t * vpath, struct stat *buf, GError ** mcerror)
{
struct vfs_s_super *super;
sftpfs_super_data_t *super_data;
LIBSSH2_SFTP_ATTRIBUTES attrs;
int res;
const vfs_path_element_t *path_element;
mc_return_val_if_error (mcerror, -1);
path_element = vfs_path_get_by_index (vpath, -1);
if (vfs_s_get_path (vpath, &super, 0) == NULL)
return -1;
if (super == NULL)
return -1;
super_data = (sftpfs_super_data_t *) super->data;
if (super_data->sftp_session == NULL)
return -1;
do
{
const char *fixfname;
fixfname = sftpfs_fix_filename (path_element->path);
res =
libssh2_sftp_stat_ex (super_data->sftp_session,
fixfname, sftpfs_filename_buffer->len, LIBSSH2_SFTP_STAT, &attrs);
if (res >= 0)
break;
if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (res == LIBSSH2_ERROR_EAGAIN);
buf->st_nlink = 1;
if ((attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID) != 0)
{
buf->st_uid = attrs.uid;
buf->st_gid = attrs.gid;
}
if ((attrs.flags & LIBSSH2_SFTP_ATTR_ACMODTIME) != 0)
{
buf->st_atime = attrs.atime;
buf->st_mtime = attrs.mtime;
buf->st_ctime = attrs.mtime;
}
if ((attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) != 0)
buf->st_size = attrs.filesize;
if ((attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) != 0)
buf->st_mode = attrs.permissions;
return 0;
}
int
sftpfs_chmod (const vfs_path_t * vpath, mode_t mode, GError ** mcerror)
{
struct vfs_s_super *super;
sftpfs_super_data_t *super_data;
LIBSSH2_SFTP_ATTRIBUTES attrs;
int res;
const vfs_path_element_t *path_element;
mc_return_val_if_error (mcerror, -1);
path_element = vfs_path_get_by_index (vpath, -1);
if (vfs_s_get_path (vpath, &super, 0) == NULL)
return -1;
if (super == NULL)
return -1;
super_data = (sftpfs_super_data_t *) super->data;
if (super_data->sftp_session == NULL)
return -1;
do
{
const char *fixfname;
fixfname = sftpfs_fix_filename (path_element->path);
res = libssh2_sftp_stat_ex (super_data->sftp_session, fixfname,
sftpfs_filename_buffer->len, LIBSSH2_SFTP_LSTAT, &attrs);
if (res >= 0)
break;
if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (res == LIBSSH2_ERROR_EAGAIN);
attrs.permissions = mode;
do
{
const char *fixfname;
fixfname = sftpfs_fix_filename (path_element->path);
res = libssh2_sftp_stat_ex (super_data->sftp_session, fixfname,
sftpfs_filename_buffer->len, LIBSSH2_SFTP_SETSTAT, &attrs);
if (res >= 0)
break;
else if (res != LIBSSH2_ERROR_EAGAIN)
{
sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
return -1;
}
sftpfs_waitsocket (super_data, mcerror);
mc_return_val_if_error (mcerror, -1);
}
while (res == LIBSSH2_ERROR_EAGAIN);
return res;
}
