src/vfs/sftpfs/file.c

   1 /* Virtual File System: SFTP file system.
   2    The internal functions: files
   3
   4    Copyright (C) 2011-2014
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Ilia Maslakov <il.smind@gmail.com>, 2011
   9    Slava Zanko <slavazanko@gmail.com>, 2011, 2012
  10
  11    This file is part of the Midnight Commander.
  12
  13    The Midnight Commander is free software: you can redistribute it
  14    and/or modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation, either version 3 of the License,
  16    or (at your option) any later version.
  17
  18    The Midnight Commander is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21    GNU General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 #include <config.h>
  28
  29 #include <libssh2.h>
  30 #include <libssh2_sftp.h>
  31
  32 #include "lib/global.h"
  33
  34 #include "internal.h"
  35
  36 /*** global variables ****************************************************************************/
  37
  38 /*** file scope macro definitions ****************************************************************/
  39
  40 /*** file scope type declarations ****************************************************************/
  41
  42 typedef struct
  43 {
  44     LIBSSH2_SFTP_HANDLE *handle;
  45     int flags;
  46     mode_t mode;
  47 } sftpfs_file_handler_data_t;
  48
  49 /*** file scope variables ************************************************************************/
  50
  51 /*** file scope functions ************************************************************************/
  52 /* --------------------------------------------------------------------------------------------- */
  53 /**
  54  * Reopen file by file handle.
  55  *
  56  * @param file_handler the file handler data
  57  * @param error        pointer to the error handler
  58  */
  59 static void
  60 sftpfs_reopen (vfs_file_handler_t * file_handler, GError ** error)
  61 {
  62     sftpfs_file_handler_data_t *file_handler_data;
  63     int flags;
  64     mode_t mode;
  65
  66     file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
  67     flags = file_handler_data->flags;
  68     mode = file_handler_data->mode;
  69
  70     sftpfs_close_file (file_handler, error);
  71     if (error == NULL || *error == NULL)
  72         sftpfs_open_file (file_handler, flags, mode, error);
  73 }
  74
  75 /* --------------------------------------------------------------------------------------------- */
  76 /*** public functions ****************************************************************************/
  77 /* --------------------------------------------------------------------------------------------- */
  78 /**
  79  * Open new SFTP file.
  80  *
  81  * @param file_handler the file handler data
  82  * @param flags        flags (see man 2 open)
  83  * @param mode         mode (see man 2 open)
  84  * @param error        pointer to the error handler
  85  * @return TRUE if connection was created successfully, FALSE otherwise
  86  */
  87
  88 gboolean
  89 sftpfs_open_file (vfs_file_handler_t * file_handler, int flags, mode_t mode, GError ** error)
  90 {
  91     unsigned long sftp_open_flags = 0;
  92     int sftp_open_mode = 0;
  93     gboolean do_append = FALSE;
  94     sftpfs_file_handler_data_t *file_handler_data;
  95     sftpfs_super_data_t *super_data;
  96     char *name;
  97
  98     (void) mode;
  99
 100     name = vfs_s_fullpath (&sftpfs_class, file_handler->ino);
 101     if (name == NULL)
 102         return FALSE;
 103
 104     super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
 105     file_handler_data = g_new0 (sftpfs_file_handler_data_t, 1);
 106
 107     if ((flags & O_CREAT) != 0 || (flags & O_WRONLY) != 0)
 108     {
 109         sftp_open_flags = (flags & O_WRONLY) != 0 ? LIBSSH2_FXF_WRITE : 0;
 110         sftp_open_flags |= (flags & O_CREAT) != 0 ? LIBSSH2_FXF_CREAT : 0;
 111         if ((flags & O_APPEND) != 0)
 112         {
 113             sftp_open_flags |= LIBSSH2_FXF_APPEND;
 114             do_append = TRUE;
 115         }
 116         sftp_open_flags |= (flags & O_TRUNC) != 0 ? LIBSSH2_FXF_TRUNC : 0;
 117
 118         sftp_open_mode = LIBSSH2_SFTP_S_IRUSR |
 119             LIBSSH2_SFTP_S_IWUSR | LIBSSH2_SFTP_S_IRGRP | LIBSSH2_SFTP_S_IROTH;
 120     }
 121     else
 122         sftp_open_flags = LIBSSH2_FXF_READ;
 123
 124     while (TRUE)
 125     {
 126         int libssh_errno;
 127
 128         file_handler_data->handle =
 129             libssh2_sftp_open (super_data->sftp_session, sftpfs_fix_filename (name),
 130                                sftp_open_flags, sftp_open_mode);
 131
 132         if (file_handler_data->handle != NULL)
 133             break;
 134
 135         libssh_errno = libssh2_session_last_errno (super_data->session);
 136         if (libssh_errno != LIBSSH2_ERROR_EAGAIN)
 137         {
 138             sftpfs_ssherror_to_gliberror (super_data, libssh_errno, error);
 139             g_free (name);
 140             g_free (file_handler_data);
 141             return FALSE;
 142         }
 143     }
 144
 145     g_free (name);
 146
 147     file_handler_data->flags = flags;
 148     file_handler_data->mode = mode;
 149     file_handler->data = file_handler_data;
 150
 151     if (do_append)
 152     {
 153         struct stat file_info;
 154
 155         if (sftpfs_fstat (file_handler, &file_info, error) == 0)
 156             libssh2_sftp_seek64 (file_handler_data->handle, file_info.st_size);
 157     }
 158     return TRUE;
 159 }
 160
 161 /* --------------------------------------------------------------------------------------------- */
 162 /**
 163  * Stats the file specified by the file descriptor.
 164  *
 165  * @param data  file data handler
 166  * @param buf   buffer for store stat-info
 167  * @param error pointer to the error handler
 168  * @return 0 if success, negative value otherwise
 169  */
 170
 171 int
 172 sftpfs_fstat (void *data, struct stat *buf, GError ** error)
 173 {
 174     int res;
 175     LIBSSH2_SFTP_ATTRIBUTES attrs;
 176     vfs_file_handler_t *fh = (vfs_file_handler_t *) data;
 177     sftpfs_file_handler_data_t *sftpfs_fh = fh->data;
 178     struct vfs_s_super *super = fh->ino->super;
 179     sftpfs_super_data_t *super_data = (sftpfs_super_data_t *) super->data;
 180
 181     if (sftpfs_fh->handle == NULL)
 182         return -1;
 183
 184     do
 185     {
 186         res = libssh2_sftp_fstat_ex (sftpfs_fh->handle, &attrs, 0);
 187         if (res >= 0)
 188             break;
 189
 190         if (res != LIBSSH2_ERROR_EAGAIN)
 191         {
 192             sftpfs_ssherror_to_gliberror (super_data, res, error);
 193             return -1;
 194         }
 195
 196         sftpfs_waitsocket (super_data, error);
 197         if (error != NULL && *error != NULL)
 198             return -1;
 199     }
 200     while (res == LIBSSH2_ERROR_EAGAIN);
 201
 202     if ((attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID) != 0)
 203     {
 204         buf->st_uid = attrs.uid;
 205         buf->st_gid = attrs.gid;
 206     }
 207
 208     if ((attrs.flags & LIBSSH2_SFTP_ATTR_ACMODTIME) != 0)
 209     {
 210         buf->st_atime = attrs.atime;
 211         buf->st_mtime = attrs.mtime;
 212         buf->st_ctime = attrs.mtime;
 213     }
 214
 215     if ((attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) != 0)
 216         buf->st_size = attrs.filesize;
 217
 218     if ((attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) != 0)
 219         buf->st_mode = attrs.permissions;
 220
 221     return 0;
 222 }
 223
 224 /* --------------------------------------------------------------------------------------------- */
 225 /**
 226  * Read up to 'count' bytes from the file descriptor 'file_handler' to the buffer starting at 'buffer'.
 227  *
 228  * @param file_handler file data handler
 229  * @param buffer buffer for data
 230  * @param count data size
 231  * @param error pointer to the error handler
 232  *
 233  * @return 0 on success, negative value otherwise
 234  */
 235
 236 ssize_t
 237 sftpfs_read_file (vfs_file_handler_t * file_handler, char *buffer, size_t count, GError ** error)
 238 {
 239     ssize_t rc;
 240     sftpfs_file_handler_data_t *file_handler_data;
 241     sftpfs_super_data_t *super_data;
 242
 243     if (file_handler == NULL || file_handler->data == NULL)
 244     {
 245         g_set_error (error, MC_ERROR, -1, _("sftp: No file handler data present for reading file"));
 246         return -1;
 247     }
 248
 249     file_handler_data = file_handler->data;
 250     super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
 251
 252     do
 253     {
 254         rc = libssh2_sftp_read (file_handler_data->handle, buffer, count);
 255         if (rc >= 0)
 256             break;
 257
 258         if (rc != LIBSSH2_ERROR_EAGAIN)
 259         {
 260             sftpfs_ssherror_to_gliberror (super_data, rc, error);
 261             return -1;
 262         }
 263
 264         sftpfs_waitsocket (super_data, error);
 265         if (error != NULL && *error != NULL)
 266             return -1;
 267     }
 268     while (rc == LIBSSH2_ERROR_EAGAIN);
 269
 270     file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
 271
 272     return rc;
 273 }
 274
 275 /* --------------------------------------------------------------------------------------------- */
 276
 277 /**
 278  * Write up to 'count' bytes from  the buffer starting at 'buffer' to the descriptor 'file_handler'.
 279  *
 280  * @param file_handler file data handler
 281  * @param buffer       buffer for data
 282  * @param count        data size
 283  * @param error        pointer to the error handler
 284  *
 285  * @return 0 on success, negative value otherwise
 286  */
 287
 288 ssize_t
 289 sftpfs_write_file (vfs_file_handler_t * file_handler, const char *buffer, size_t count,
 290                    GError ** error)
 291 {
 292     ssize_t rc;
 293     sftpfs_file_handler_data_t *file_handler_data;
 294     sftpfs_super_data_t *super_data;
 295
 296     file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
 297     super_data = (sftpfs_super_data_t *) file_handler->ino->super->data;
 298
 299     file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
 300
 301     do
 302     {
 303         rc = libssh2_sftp_write (file_handler_data->handle, buffer, count);
 304         if (rc >= 0)
 305             break;
 306
 307         if (rc != LIBSSH2_ERROR_EAGAIN)
 308         {
 309             sftpfs_ssherror_to_gliberror (super_data, rc, error);
 310             return -1;
 311         }
 312
 313         sftpfs_waitsocket (super_data, error);
 314         if (error != NULL && *error != NULL)
 315             return -1;
 316     }
 317     while (rc == LIBSSH2_ERROR_EAGAIN);
 318
 319     return rc;
 320 }
 321
 322 /* --------------------------------------------------------------------------------------------- */
 323
 324 /**
 325  * Close a file descriptor.
 326  *
 327  * @param file_handler    file data handler
 328  * @param error           pointer to the error handler
 329  *
 330  * @return 0 on success, negative value otherwise
 331  */
 332
 333 int
 334 sftpfs_close_file (vfs_file_handler_t * file_handler, GError ** error)
 335 {
 336     sftpfs_file_handler_data_t *file_handler_data;
 337
 338     (void) error;
 339
 340     file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
 341     if (file_handler_data == NULL)
 342         return -1;
 343
 344     libssh2_sftp_close (file_handler_data->handle);
 345
 346     g_free (file_handler_data);
 347     return 0;
 348 }
 349
 350 /* --------------------------------------------------------------------------------------------- */
 351
 352 /**
 353  * Reposition the offset of the open file associated with the file descriptor.
 354  *
 355  * @param file_handler   file data handler
 356  * @param offset         file offset
 357  * @param whence         method of seek (at begin, at current, at end)
 358  * @param error          pointer to the error handler
 359  *
 360  * @return 0 on success, negative value otherwise
 361  */
 362
 363 off_t
 364 sftpfs_lseek (vfs_file_handler_t * file_handler, off_t offset, int whence, GError ** error)
 365 {
 366     sftpfs_file_handler_data_t *file_handler_data;
 367
 368     switch (whence)
 369     {
 370     case SEEK_SET:
 371         /* Need reopen file because:
 372            "You MUST NOT seek during writing or reading a file with SFTP, as the internals use
 373            outstanding packets and changing the "file position" during transit will results in
 374            badness." */
 375         if (file_handler->pos > offset || offset == 0)
 376         {
 377             sftpfs_reopen (file_handler, error);
 378             if (error != NULL && *error != NULL)
 379                 return 0;
 380         }
 381         file_handler->pos = offset;
 382         break;
 383     case SEEK_CUR:
 384         file_handler->pos += offset;
 385         break;
 386     case SEEK_END:
 387         if (file_handler->pos > file_handler->ino->st.st_size - offset)
 388         {
 389             sftpfs_reopen (file_handler, error);
 390             if (error != NULL && *error != NULL)
 391                 return 0;
 392         }
 393         file_handler->pos = file_handler->ino->st.st_size - offset;
 394         break;
 395     }
 396
 397     file_handler_data = (sftpfs_file_handler_data_t *) file_handler->data;
 398
 399     libssh2_sftp_seek64 (file_handler_data->handle, file_handler->pos);
 400     file_handler->pos = (off_t) libssh2_sftp_tell64 (file_handler_data->handle);
 401
 402     return file_handler->pos;
 403 }
 404
 405 /* --------------------------------------------------------------------------------------------- */