src/vfs/sftpfs/internal.c

   1 /* Virtual File System: SFTP file system.
   2    The internal functions
   3
   4    Copyright (C) 2011-2017
   5    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 #include <errno.h>
  29
  30 #include "lib/global.h"
  31 #include "lib/util.h"
  32
  33 #include "internal.h"
  34
  35 /*** global variables ****************************************************************************/
  36
  37 GString *sftpfs_filename_buffer = NULL;
  38
  39 /*** file scope macro definitions ****************************************************************/
  40
  41 /*** file scope type declarations ****************************************************************/
  42
  43 /*** file scope variables ************************************************************************/
  44
  45 /* --------------------------------------------------------------------------------------------- */
  46 /*** file scope functions ************************************************************************/
  47 /* --------------------------------------------------------------------------------------------- */
  48
  49 static gboolean
  50 sftpfs_is_sftp_error (LIBSSH2_SFTP * sftp_session, int sftp_res, int sftp_error)
  51 {
  52     return (sftp_res == LIBSSH2_ERROR_SFTP_PROTOCOL &&
  53             libssh2_sftp_last_error (sftp_session) == (unsigned long) sftp_error);
  54 }
  55
  56 /* --------------------------------------------------------------------------------------------- */
  57
  58 /* Adjust block size and number of blocks */
  59
  60 static void
  61 sftpfs_blksize (struct stat *s)
  62 {
  63 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
  64     s->st_blksize = LIBSSH2_CHANNEL_WINDOW_DEFAULT;     /* FIXME */
  65 #endif /* HAVE_STRUCT_STAT_ST_BLKSIZE */
  66     vfs_adjust_stat (s);
  67 }
  68
  69 /* --------------------------------------------------------------------------------------------- */
  70
  71 static gboolean
  72 sftpfs_waitsocket_or_error (sftpfs_super_data_t * super_data, int res, GError ** mcerror,
  73                             void *to_free)
  74 {
  75     if (res != LIBSSH2_ERROR_EAGAIN)
  76     {
  77         sftpfs_ssherror_to_gliberror (super_data, res, mcerror);
  78         g_free (to_free);
  79         return FALSE;
  80     }
  81
  82     sftpfs_waitsocket (super_data, mcerror);
  83
  84     if (mcerror != NULL && *mcerror != NULL)
  85     {
  86         g_free (to_free);
  87         return FALSE;
  88     }
  89
  90     return TRUE;
  91 }
  92
  93 /* --------------------------------------------------------------------------------------------- */
  94 /*** public functions ****************************************************************************/
  95 /* --------------------------------------------------------------------------------------------- */
  96 /**
  97  * Convert libssh error to GError object.
  98  *
  99  * @param super_data   extra data for SFTP connection
 100  * @param libssh_errno errno from libssh
 101  * @param mcerror      pointer to the error object
 102  */
 103
 104 void
 105 sftpfs_ssherror_to_gliberror (sftpfs_super_data_t * super_data, int libssh_errno, GError ** mcerror)
 106 {
 107     char *err = NULL;
 108     int err_len;
 109
 110     mc_return_if_error (mcerror);
 111
 112     libssh2_session_last_error (super_data->session, &err, &err_len, 1);
 113     if (libssh_errno == LIBSSH2_ERROR_SFTP_PROTOCOL && super_data->sftp_session != NULL)
 114         mc_propagate_error (mcerror, libssh_errno, "%s %lu", err,
 115                             libssh2_sftp_last_error (super_data->sftp_session));
 116     else
 117         mc_propagate_error (mcerror, libssh_errno, "%s", err);
 118     g_free (err);
 119 }
 120
 121 /* --------------------------------------------------------------------------------------------- */
 122 /**
 123  * Fix filename for SFTP operations: add leading slash to file name.
 124  *
 125  * @param file_name file name
 126  * @param length length of returned string
 127  *
 128  * @return pointer to string that contains the file name with leading slash
 129  */
 130
 131 const char *
 132 sftpfs_fix_filename (const char *file_name, unsigned int *length)
 133 {
 134     g_string_printf (sftpfs_filename_buffer, "%c%s", PATH_SEP, file_name);
 135     *length = sftpfs_filename_buffer->len;
 136     return sftpfs_filename_buffer->str;
 137 }
 138
 139 /* --------------------------------------------------------------------------------------------- */
 140 /**
 141  * Awaiting for any activity on socket.
 142  *
 143  * @param super_data extra data for SFTP connection
 144  * @param mcerror    pointer to the error object
 145  * @return 0 if success, negative value otherwise
 146  */
 147
 148 int
 149 sftpfs_waitsocket (sftpfs_super_data_t * super_data, GError ** mcerror)
 150 {
 151     struct timeval timeout = { 10, 0 };
 152     fd_set fd;
 153     fd_set *writefd = NULL;
 154     fd_set *readfd = NULL;
 155     int dir;
 156
 157     mc_return_val_if_error (mcerror, -1);
 158
 159     FD_ZERO (&fd);
 160     FD_SET (super_data->socket_handle, &fd);
 161
 162     /* now make sure we wait in the correct direction */
 163     dir = libssh2_session_block_directions (super_data->session);
 164
 165     if ((dir & LIBSSH2_SESSION_BLOCK_INBOUND) != 0)
 166         readfd = &fd;
 167
 168     if ((dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0)
 169         writefd = &fd;
 170
 171     return select (super_data->socket_handle + 1, readfd, writefd, NULL, &timeout);
 172 }
 173
 174 /* --------------------------------------------------------------------------------------------- */
 175
 176 void
 177 sftpfs_attr_to_stat (const LIBSSH2_SFTP_ATTRIBUTES * attrs, struct stat *s)
 178 {
 179     if ((attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) != 0)
 180     {
 181         s->st_uid = attrs->uid;
 182         s->st_gid = attrs->gid;
 183     }
 184
 185     if ((attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) != 0)
 186     {
 187         s->st_atime = attrs->atime;
 188         s->st_mtime = attrs->mtime;
 189         s->st_ctime = attrs->mtime;
 190 #ifdef HAVE_STRUCT_STAT_ST_MTIM
 191         s->st_atim.tv_nsec = s->st_mtim.tv_nsec = s->st_ctim.tv_nsec = 0;
 192 #endif
 193     }
 194
 195     if ((attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) != 0)
 196     {
 197         s->st_size = attrs->filesize;
 198         sftpfs_blksize (s);
 199     }
 200
 201     if ((attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) != 0)
 202         s->st_mode = attrs->permissions;
 203 }
 204
 205 /* --------------------------------------------------------------------------------------------- */
 206 /**
 207  * Getting information about a symbolic link.
 208  *
 209  * @param vpath   path to file, directory or symbolic link
 210  * @param buf     buffer for store stat-info
 211  * @param mcerror pointer to error object
 212  * @return 0 if success, negative value otherwise
 213  */
 214
 215 int
 216 sftpfs_lstat (const vfs_path_t * vpath, struct stat *buf, GError ** mcerror)
 217 {
 218     struct vfs_s_super *super;
 219     sftpfs_super_data_t *super_data;
 220     LIBSSH2_SFTP_ATTRIBUTES attrs;
 221     int res;
 222     const vfs_path_element_t *path_element;
 223
 224     mc_return_val_if_error (mcerror, -1);
 225
 226     path_element = vfs_path_get_by_index (vpath, -1);
 227
 228     if (vfs_s_get_path (vpath, &super, 0) == NULL)
 229         return -1;
 230
 231     if (super == NULL)
 232         return -1;
 233
 234     super_data = (sftpfs_super_data_t *) super->data;
 235     if (super_data->sftp_session == NULL)
 236         return -1;
 237
 238     do
 239     {
 240         const char *fixfname;
 241         unsigned int fixfname_len = 0;
 242
 243         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 244
 245         res =
 246             libssh2_sftp_stat_ex (super_data->sftp_session, fixfname, fixfname_len,
 247                                   LIBSSH2_SFTP_LSTAT, &attrs);
 248         if (res >= 0)
 249             break;
 250
 251         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_PERMISSION_DENIED))
 252             return -EACCES;
 253
 254         /* perhaps the copy function tries to stat destination file
 255            to make sure it's not overwriting anything */
 256         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_NO_SUCH_FILE))
 257             return -ENOENT;
 258
 259         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 260             return -1;
 261     }
 262     while (res == LIBSSH2_ERROR_EAGAIN);
 263
 264     sftpfs_attr_to_stat (&attrs, buf);
 265
 266     return 0;
 267 }
 268
 269 /* --------------------------------------------------------------------------------------------- */
 270 /**
 271  * Getting information about a file or directory.
 272  *
 273  * @param vpath   path to file or directory
 274  * @param buf     buffer for store stat-info
 275  * @param mcerror pointer to error object
 276  * @return 0 if success, negative value otherwise
 277  */
 278
 279 int
 280 sftpfs_stat (const vfs_path_t * vpath, struct stat *buf, GError ** mcerror)
 281 {
 282     struct vfs_s_super *super;
 283     sftpfs_super_data_t *super_data;
 284     LIBSSH2_SFTP_ATTRIBUTES attrs;
 285     int res;
 286     const vfs_path_element_t *path_element;
 287
 288     mc_return_val_if_error (mcerror, -1);
 289
 290     path_element = vfs_path_get_by_index (vpath, -1);
 291
 292     if (vfs_s_get_path (vpath, &super, 0) == NULL)
 293         return -1;
 294
 295     if (super == NULL)
 296         return -1;
 297
 298     super_data = (sftpfs_super_data_t *) super->data;
 299     if (super_data->sftp_session == NULL)
 300         return -1;
 301
 302     do
 303     {
 304         const char *fixfname;
 305         unsigned int fixfname_len = 0;
 306
 307         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 308
 309         res =
 310             libssh2_sftp_stat_ex (super_data->sftp_session, fixfname, fixfname_len,
 311                                   LIBSSH2_SFTP_STAT, &attrs);
 312         if (res >= 0)
 313             break;
 314
 315         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_PERMISSION_DENIED))
 316             return -EACCES;
 317
 318         /* perhaps the copy function tries to stat destination file
 319            to make sure it's not overwriting anything */
 320         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_NO_SUCH_FILE))
 321             return -ENOENT;
 322
 323         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 324             return -1;
 325     }
 326     while (res == LIBSSH2_ERROR_EAGAIN);
 327
 328     buf->st_nlink = 1;
 329
 330     sftpfs_attr_to_stat (&attrs, buf);
 331
 332     return 0;
 333 }
 334
 335 /* --------------------------------------------------------------------------------------------- */
 336 /**
 337  * Read value of a symbolic link.
 338  *
 339  * @param vpath   path to file or directory
 340  * @param buf     buffer for store stat-info
 341  * @param size    buffer size
 342  * @param mcerror pointer to error object
 343  * @return 0 if success, negative value otherwise
 344  */
 345
 346 int
 347 sftpfs_readlink (const vfs_path_t * vpath, char *buf, size_t size, GError ** mcerror)
 348 {
 349     struct vfs_s_super *super;
 350     sftpfs_super_data_t *super_data;
 351     int res;
 352     const vfs_path_element_t *path_element;
 353
 354     mc_return_val_if_error (mcerror, -1);
 355
 356     path_element = vfs_path_get_by_index (vpath, -1);
 357
 358     if (vfs_s_get_path (vpath, &super, 0) == NULL)
 359         return -1;
 360
 361     if (super == NULL)
 362         return -1;
 363
 364     super_data = (sftpfs_super_data_t *) super->data;
 365     if (super_data->sftp_session == NULL)
 366         return -1;
 367
 368     do
 369     {
 370         const char *fixfname;
 371         unsigned int fixfname_len = 0;
 372
 373         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 374
 375         res =
 376             libssh2_sftp_symlink_ex (super_data->sftp_session, fixfname, fixfname_len, buf, size,
 377                                      LIBSSH2_SFTP_READLINK);
 378         if (res >= 0)
 379             break;
 380
 381         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 382             return -1;
 383     }
 384     while (res == LIBSSH2_ERROR_EAGAIN);
 385
 386     return res;
 387 }
 388
 389 /* --------------------------------------------------------------------------------------------- */
 390 /**
 391  * Create symlink to file or directory
 392  *
 393  * @param vpath1  path to file or directory
 394  * @param vpath2  path to symlink
 395  * @param mcerror pointer to error object
 396  * @return 0 if success, negative value otherwise
 397  */
 398
 399 int
 400 sftpfs_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2, GError ** mcerror)
 401 {
 402     struct vfs_s_super *super;
 403     sftpfs_super_data_t *super_data;
 404     const vfs_path_element_t *path_element1;
 405     const vfs_path_element_t *path_element2;
 406     char *tmp_path;
 407     unsigned int tmp_path_len;
 408     int res;
 409
 410     mc_return_val_if_error (mcerror, -1);
 411
 412     path_element2 = vfs_path_get_by_index (vpath2, -1);
 413
 414     if (vfs_s_get_path (vpath2, &super, 0) == NULL)
 415         return -1;
 416
 417     if (super == NULL)
 418         return -1;
 419
 420     super_data = (sftpfs_super_data_t *) super->data;
 421     if (super_data->sftp_session == NULL)
 422         return -1;
 423
 424     tmp_path = (char *) sftpfs_fix_filename (path_element2->path, &tmp_path_len);
 425     tmp_path = g_strndup (tmp_path, tmp_path_len);
 426
 427     path_element1 = vfs_path_get_by_index (vpath1, -1);
 428
 429     do
 430     {
 431         const char *fixfname;
 432         unsigned int fixfname_len = 0;
 433
 434         fixfname = sftpfs_fix_filename (path_element1->path, &fixfname_len);
 435
 436         res =
 437             libssh2_sftp_symlink_ex (super_data->sftp_session, fixfname, fixfname_len, tmp_path,
 438                                      tmp_path_len, LIBSSH2_SFTP_SYMLINK);
 439         if (res >= 0)
 440             break;
 441
 442         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, tmp_path))
 443             return -1;
 444     }
 445     while (res == LIBSSH2_ERROR_EAGAIN);
 446     g_free (tmp_path);
 447
 448     return 0;
 449 }
 450
 451 /* --------------------------------------------------------------------------------------------- */
 452 /**
 453  * Changes the permissions of the file.
 454  *
 455  * @param vpath   path to file or directory
 456  * @param mode    mode (see man 2 open)
 457  * @param mcerror pointer to error object
 458  * @return 0 if success, negative value otherwise
 459  */
 460
 461 int
 462 sftpfs_chmod (const vfs_path_t * vpath, mode_t mode, GError ** mcerror)
 463 {
 464     struct vfs_s_super *super;
 465     sftpfs_super_data_t *super_data;
 466     LIBSSH2_SFTP_ATTRIBUTES attrs;
 467     int res;
 468     const vfs_path_element_t *path_element;
 469
 470     mc_return_val_if_error (mcerror, -1);
 471
 472     path_element = vfs_path_get_by_index (vpath, -1);
 473
 474     if (vfs_s_get_path (vpath, &super, 0) == NULL)
 475         return -1;
 476
 477     if (super == NULL)
 478         return -1;
 479
 480     super_data = (sftpfs_super_data_t *) super->data;
 481     if (super_data->sftp_session == NULL)
 482         return -1;
 483
 484     do
 485     {
 486         const char *fixfname;
 487         unsigned int fixfname_len = 0;
 488
 489         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 490
 491         res =
 492             libssh2_sftp_stat_ex (super_data->sftp_session, fixfname, fixfname_len,
 493                                   LIBSSH2_SFTP_LSTAT, &attrs);
 494         if (res >= 0)
 495             break;
 496
 497         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_PERMISSION_DENIED))
 498             return -EACCES;
 499
 500         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_FAILURE))
 501         {
 502             res = 0;            /* need something like ftpfs_ignore_chattr_errors */
 503             break;
 504         }
 505
 506         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 507             return -1;
 508     }
 509     while (res == LIBSSH2_ERROR_EAGAIN);
 510
 511     attrs.permissions = mode;
 512
 513     do
 514     {
 515         const char *fixfname;
 516         unsigned int fixfname_len = 0;
 517
 518         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 519
 520         res =
 521             libssh2_sftp_stat_ex (super_data->sftp_session, fixfname, fixfname_len,
 522                                   LIBSSH2_SFTP_SETSTAT, &attrs);
 523         if (res >= 0)
 524             break;
 525
 526         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_NO_SUCH_FILE))
 527             return -ENOENT;
 528
 529         if (sftpfs_is_sftp_error (super_data->sftp_session, res, LIBSSH2_FX_FAILURE))
 530         {
 531             res = 0;            /* need something like ftpfs_ignore_chattr_errors */
 532             break;
 533         }
 534
 535         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 536             return -1;
 537     }
 538     while (res == LIBSSH2_ERROR_EAGAIN);
 539
 540     return res;
 541 }
 542
 543 /* --------------------------------------------------------------------------------------------- */
 544 /**
 545  * Delete a name from the file system.
 546  *
 547  * @param vpath   path to file or directory
 548  * @param mcerror pointer to error object
 549  * @return 0 if success, negative value otherwise
 550  */
 551
 552 int
 553 sftpfs_unlink (const vfs_path_t * vpath, GError ** mcerror)
 554 {
 555     struct vfs_s_super *super;
 556     sftpfs_super_data_t *super_data;
 557     int res;
 558     const vfs_path_element_t *path_element;
 559
 560     mc_return_val_if_error (mcerror, -1);
 561
 562     path_element = vfs_path_get_by_index (vpath, -1);
 563
 564     if (vfs_s_get_path (vpath, &super, 0) == NULL)
 565         return -1;
 566
 567     if (super == NULL)
 568         return -1;
 569
 570     super_data = (sftpfs_super_data_t *) super->data;
 571     if (super_data->sftp_session == NULL)
 572         return -1;
 573
 574     do
 575     {
 576         const char *fixfname;
 577         unsigned int fixfname_len = 0;
 578
 579         fixfname = sftpfs_fix_filename (path_element->path, &fixfname_len);
 580
 581         res = libssh2_sftp_unlink_ex (super_data->sftp_session, fixfname, fixfname_len);
 582         if (res >= 0)
 583             break;
 584
 585         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, NULL))
 586             return -1;
 587     }
 588     while (res == LIBSSH2_ERROR_EAGAIN);
 589
 590     return res;
 591 }
 592
 593 /* --------------------------------------------------------------------------------------------- */
 594 /**
 595  * Rename a file, moving it between directories if required.
 596  *
 597  * @param vpath1   path to source file or directory
 598  * @param vpath2   path to destination file or directory
 599  * @param mcerror  pointer to error object
 600  * @return 0 if success, negative value otherwise
 601  */
 602
 603 int
 604 sftpfs_rename (const vfs_path_t * vpath1, const vfs_path_t * vpath2, GError ** mcerror)
 605 {
 606     struct vfs_s_super *super;
 607     sftpfs_super_data_t *super_data;
 608     const vfs_path_element_t *path_element1;
 609     const vfs_path_element_t *path_element2;
 610     char *tmp_path;
 611     unsigned int tmp_path_len;
 612     int res;
 613
 614     mc_return_val_if_error (mcerror, -1);
 615     path_element2 = vfs_path_get_by_index (vpath2, -1);
 616
 617     if (vfs_s_get_path (vpath2, &super, 0) == NULL)
 618         return -1;
 619
 620     if (super == NULL)
 621         return -1;
 622
 623     super_data = (sftpfs_super_data_t *) super->data;
 624     if (super_data->sftp_session == NULL)
 625         return -1;
 626
 627     tmp_path = (char *) sftpfs_fix_filename (path_element2->path, &tmp_path_len);
 628     tmp_path = g_strndup (tmp_path, tmp_path_len);
 629
 630     path_element1 = vfs_path_get_by_index (vpath1, -1);
 631
 632     do
 633     {
 634         const char *fixfname;
 635         unsigned int fixfname_len = 0;
 636
 637         fixfname = sftpfs_fix_filename (path_element1->path, &fixfname_len);
 638
 639         res =
 640             libssh2_sftp_rename_ex (super_data->sftp_session, fixfname, fixfname_len, tmp_path,
 641                                     tmp_path_len, LIBSSH2_SFTP_SYMLINK);
 642         if (res >= 0)
 643             break;
 644
 645         if (!sftpfs_waitsocket_or_error (super_data, res, mcerror, tmp_path))
 646             return -1;
 647     }
 648     while (res == LIBSSH2_ERROR_EAGAIN);
 649     g_free (tmp_path);
 650
 651     return 0;
 652 }
 653
 654 /* --------------------------------------------------------------------------------------------- */