lib/vfs/vfs.c

   1 /*
   2    Virtual File System switch code
   3
   4    Copyright (C) 1995-2019
   5    Free Software Foundation, Inc.
   6
   7    Written by: 1995 Miguel de Icaza
   8    Jakub Jelinek, 1995
   9    Pavel Machek, 1998
  10    Slava Zanko <slavazanko@gmail.com>, 2013
  11
  12    This file is part of the Midnight Commander.
  13
  14    The Midnight Commander is free software: you can redistribute it
  15    and/or modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation, either version 3 of the License,
  17    or (at your option) any later version.
  18
  19    The Midnight Commander is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26  */
  27
  28 /**
  29  * \file
  30  * \brief Source: Virtual File System switch code
  31  * \author Miguel de Icaza
  32  * \author Jakub Jelinek
  33  * \author Pavel Machek
  34  * \date 1995, 1998
  35  * \warning functions like extfs_lstat() have right to destroy any
  36  * strings you pass to them. This is acutally ok as you g_strdup what
  37  * you are passing to them, anyway; still, beware.
  38  *
  39  * Namespace: exports *many* functions with vfs_ prefix; exports
  40  * parse_ls_lga and friends which do not have that prefix.
  41  */
  42
  43 #include <config.h>
  44
  45 #include <errno.h>
  46 #include <stdlib.h>
  47
  48 #ifdef __linux__
  49 #ifdef HAVE_LINUX_FS_H
  50 #include <linux/fs.h>
  51 #endif /* HAVE_LINUX_FS_H */
  52 #ifdef HAVE_SYS_IOCTL_H
  53 #include <sys/ioctl.h>
  54 #endif /* HAVE_SYS_IOCTL_H */
  55 #endif /* __linux__ */
  56
  57 #include "lib/global.h"
  58 #include "lib/strutil.h"
  59 #include "lib/util.h"
  60 #include "lib/widget.h"         /* message() */
  61 #include "lib/event.h"
  62
  63 #ifdef HAVE_CHARSET
  64 #include "lib/charsets.h"
  65 #endif
  66
  67 #include "vfs.h"
  68 #include "utilvfs.h"
  69 #include "gc.h"
  70
  71 /* TODO: move it to the separate .h */
  72 extern struct dirent *mc_readdir_result;
  73 extern GPtrArray *vfs__classes_list;
  74 extern GString *vfs_str_buffer;
  75 extern vfs_class *current_vfs;
  76
  77 /*** global variables ****************************************************************************/
  78
  79 GPtrArray *vfs__classes_list = NULL;
  80 GString *vfs_str_buffer = NULL;
  81 vfs_class *current_vfs = NULL;
  82
  83 /*** file scope macro definitions ****************************************************************/
  84
  85 #define VFS_FIRST_HANDLE 100
  86
  87 /*** file scope type declarations ****************************************************************/
  88
  89 struct vfs_openfile
  90 {
  91     int handle;
  92     vfs_class *vclass;
  93     void *fsinfo;
  94 };
  95
  96 /*** file scope variables ************************************************************************/
  97
  98 /** They keep track of the current directory */
  99 static vfs_path_t *current_path = NULL;
 100
 101 static GPtrArray *vfs_openfiles = NULL;
 102 static long vfs_free_handle_list = -1;
 103
 104 /* --------------------------------------------------------------------------------------------- */
 105 /*** file scope functions ************************************************************************/
 106 /* --------------------------------------------------------------------------------------------- */
 107 /* now used only by vfs_translate_path, but could be used in other vfs
 108  * plugin to automatic detect encoding
 109  * path - path to translate
 110  * size - how many bytes from path translate
 111  * defcnv - convertor, that is used as default, when path does not contain any
 112  *          #enc: subtring
 113  * buffer - used to store result of translation
 114  */
 115
 116 static estr_t
 117 _vfs_translate_path (const char *path, int size, GIConv defcnv, GString * buffer)
 118 {
 119     estr_t state = ESTR_SUCCESS;
 120 #ifdef HAVE_CHARSET
 121     const char *semi;
 122
 123     if (size == 0)
 124         return ESTR_SUCCESS;
 125
 126     size = (size > 0) ? size : (signed int) strlen (path);
 127
 128     /* try found /#enc: */
 129     semi = g_strrstr_len (path, size, VFS_ENCODING_PREFIX);
 130     if (semi != NULL && (semi == path || IS_PATH_SEP (semi[-1])))
 131     {
 132         char encoding[16];
 133         const char *slash;
 134         GIConv coder = INVALID_CONV;
 135         int ms;
 136
 137         /* first must be translated part before #enc: */
 138         ms = semi - path;
 139
 140         state = _vfs_translate_path (path, ms, defcnv, buffer);
 141
 142         if (state != ESTR_SUCCESS)
 143             return state;
 144
 145         /* now can be translated part after #enc: */
 146         semi += strlen (VFS_ENCODING_PREFIX);   /* skip "#enc:" */
 147         slash = strchr (semi, PATH_SEP);
 148         /* ignore slashes after size; */
 149         if (slash - path >= size)
 150             slash = NULL;
 151
 152         ms = (slash != NULL) ? slash - semi : (int) strlen (semi);
 153         ms = MIN ((unsigned int) ms, sizeof (encoding) - 1);
 154         /* limit encoding size (ms) to path size (size) */
 155         if (semi + ms > path + size)
 156             ms = path + size - semi;
 157         memcpy (encoding, semi, ms);
 158         encoding[ms] = '\0';
 159
 160         if (is_supported_encoding (encoding))
 161             coder = str_crt_conv_to (encoding);
 162
 163         if (coder != INVALID_CONV)
 164         {
 165             if (slash != NULL)
 166                 state = str_vfs_convert_to (coder, slash + 1, path + size - slash - 1, buffer);
 167             str_close_conv (coder);
 168             return state;
 169         }
 170
 171         errno = EINVAL;
 172         state = ESTR_FAILURE;
 173     }
 174     else
 175     {
 176         /* path can be translated whole at once */
 177         state = str_vfs_convert_to (defcnv, path, size, buffer);
 178     }
 179 #else
 180     (void) size;
 181     (void) defcnv;
 182
 183     g_string_assign (buffer, path);
 184 #endif /* HAVE_CHARSET */
 185
 186     return state;
 187 }
 188
 189 /* --------------------------------------------------------------------------------------------- */
 190
 191 static struct vfs_openfile *
 192 vfs_get_openfile (int handle)
 193 {
 194     struct vfs_openfile *h;
 195
 196     if (handle < VFS_FIRST_HANDLE || (guint) (handle - VFS_FIRST_HANDLE) >= vfs_openfiles->len)
 197         return NULL;
 198
 199     h = (struct vfs_openfile *) g_ptr_array_index (vfs_openfiles, handle - VFS_FIRST_HANDLE);
 200     if (h == NULL)
 201         return NULL;
 202
 203     g_assert (h->handle == handle);
 204
 205     return h;
 206 }
 207
 208 /* --------------------------------------------------------------------------------------------- */
 209
 210 static gboolean
 211 vfs_test_current_dir (const vfs_path_t * vpath)
 212 {
 213     struct stat my_stat, my_stat2;
 214
 215     return (mc_global.vfs.cd_symlinks && mc_stat (vpath, &my_stat) == 0
 216             && mc_stat (vfs_get_raw_current_dir (), &my_stat2) == 0
 217             && my_stat.st_ino == my_stat2.st_ino && my_stat.st_dev == my_stat2.st_dev);
 218 }
 219
 220
 221 /* --------------------------------------------------------------------------------------------- */
 222 /*** public functions ****************************************************************************/
 223 /* --------------------------------------------------------------------------------------------- */
 224 /** Free open file data for given file handle */
 225
 226 void
 227 vfs_free_handle (int handle)
 228 {
 229     const int idx = handle - VFS_FIRST_HANDLE;
 230
 231     if (handle >= VFS_FIRST_HANDLE && (guint) idx < vfs_openfiles->len)
 232     {
 233         struct vfs_openfile *h;
 234
 235         h = (struct vfs_openfile *) g_ptr_array_index (vfs_openfiles, idx);
 236         g_free (h);
 237         g_ptr_array_index (vfs_openfiles, idx) = (void *) vfs_free_handle_list;
 238         vfs_free_handle_list = idx;
 239     }
 240 }
 241
 242
 243 /* --------------------------------------------------------------------------------------------- */
 244 /** Find VFS class by file handle */
 245
 246 struct vfs_class *
 247 vfs_class_find_by_handle (int handle, void **fsinfo)
 248 {
 249     struct vfs_openfile *h;
 250
 251     h = vfs_get_openfile (handle);
 252
 253     if (h == NULL)
 254         return NULL;
 255
 256     if (fsinfo != NULL)
 257         *fsinfo = h->fsinfo;
 258
 259     return h->vclass;
 260 }
 261
 262 /* --------------------------------------------------------------------------------------------- */
 263
 264 /**
 265  * Create new VFS handle and put it to the list
 266  */
 267
 268 int
 269 vfs_new_handle (struct vfs_class *vclass, void *fsinfo)
 270 {
 271     struct vfs_openfile *h;
 272
 273     h = g_new (struct vfs_openfile, 1);
 274     h->fsinfo = fsinfo;
 275     h->vclass = vclass;
 276
 277     /* Allocate the first free handle */
 278     h->handle = vfs_free_handle_list;
 279     if (h->handle == -1)
 280     {
 281         /* No free allocated handles, allocate one */
 282         h->handle = vfs_openfiles->len;
 283         g_ptr_array_add (vfs_openfiles, h);
 284     }
 285     else
 286     {
 287         vfs_free_handle_list = (long) g_ptr_array_index (vfs_openfiles, vfs_free_handle_list);
 288         g_ptr_array_index (vfs_openfiles, h->handle) = h;
 289     }
 290
 291     h->handle += VFS_FIRST_HANDLE;
 292     return h->handle;
 293 }
 294
 295 /* --------------------------------------------------------------------------------------------- */
 296
 297 int
 298 vfs_ferrno (struct vfs_class *vfs)
 299 {
 300     return vfs->ferrno ? (*vfs->ferrno) (vfs) : E_UNKNOWN;
 301     /* Hope that error message is obscure enough ;-) */
 302 }
 303
 304 /* --------------------------------------------------------------------------------------------- */
 305
 306 gboolean
 307 vfs_register_class (struct vfs_class * vfs)
 308 {
 309     if (vfs->init != NULL)      /* vfs has own initialization function */
 310         if (!vfs->init (vfs))   /* but it failed */
 311             return FALSE;
 312
 313     g_ptr_array_add (vfs__classes_list, vfs);
 314
 315     return TRUE;
 316 }
 317
 318 /* --------------------------------------------------------------------------------------------- */
 319 /** Strip known vfs suffixes from a filename (possible improvement: strip
 320  *  suffix from last path component).
 321  *  \return a malloced string which has to be freed.
 322  */
 323
 324 char *
 325 vfs_strip_suffix_from_filename (const char *filename)
 326 {
 327     char *semi, *p;
 328
 329     if (filename == NULL)
 330         vfs_die ("vfs_strip_suffix_from_path got NULL: impossible");
 331
 332     p = g_strdup (filename);
 333     semi = g_strrstr (p, VFS_PATH_URL_DELIMITER);
 334     if (semi != NULL)
 335     {
 336         char *vfs_prefix;
 337
 338         *semi = '\0';
 339         vfs_prefix = strrchr (p, PATH_SEP);
 340         if (vfs_prefix == NULL)
 341             *semi = *VFS_PATH_URL_DELIMITER;
 342         else
 343             *vfs_prefix = '\0';
 344     }
 345
 346     return p;
 347 }
 348
 349 /* --------------------------------------------------------------------------------------------- */
 350
 351 const char *
 352 vfs_translate_path (const char *path)
 353 {
 354     estr_t state;
 355
 356     g_string_set_size (vfs_str_buffer, 0);
 357     state = _vfs_translate_path (path, -1, str_cnv_from_term, vfs_str_buffer);
 358     return (state != ESTR_FAILURE) ? vfs_str_buffer->str : NULL;
 359 }
 360
 361 /* --------------------------------------------------------------------------------------------- */
 362
 363 char *
 364 vfs_translate_path_n (const char *path)
 365 {
 366     const char *result;
 367
 368     result = vfs_translate_path (path);
 369     return g_strdup (result);
 370 }
 371
 372 /* --------------------------------------------------------------------------------------------- */
 373 /**
 374  * Get current directory without any OS calls.
 375  *
 376  * @return string contains current path
 377  */
 378
 379 const char *
 380 vfs_get_current_dir (void)
 381 {
 382     return current_path->str;
 383 }
 384
 385 /* --------------------------------------------------------------------------------------------- */
 386 /**
 387  * Get current directory without any OS calls.
 388  *
 389  * @return newly allocated string contains current path
 390  */
 391
 392 char *
 393 vfs_get_current_dir_n (void)
 394 {
 395     return g_strdup (current_path->str);
 396 }
 397
 398 /* --------------------------------------------------------------------------------------------- */
 399 /**
 400  * Get raw current directory object without any OS calls.
 401  *
 402  * @return object contain current path
 403  */
 404
 405 const vfs_path_t *
 406 vfs_get_raw_current_dir (void)
 407 {
 408     return current_path;
 409 }
 410
 411 /* --------------------------------------------------------------------------------------------- */
 412 /**
 413  * Set current directory object.
 414  *
 415  * @param vpath new path
 416  */
 417 void
 418 vfs_set_raw_current_dir (const vfs_path_t * vpath)
 419 {
 420     vfs_path_free (current_path);
 421     current_path = (vfs_path_t *) vpath;
 422 }
 423
 424 /* --------------------------------------------------------------------------------------------- */
 425 /* Return TRUE is the current VFS class is local */
 426
 427 gboolean
 428 vfs_current_is_local (void)
 429 {
 430     return (current_vfs->flags & VFSF_LOCAL) != 0;
 431 }
 432
 433 /* --------------------------------------------------------------------------------------------- */
 434 /* Return flags of the VFS class of the given filename */
 435
 436 vfs_class_flags_t
 437 vfs_file_class_flags (const vfs_path_t * vpath)
 438 {
 439     const vfs_path_element_t *path_element;
 440
 441     path_element = vfs_path_get_by_index (vpath, -1);
 442     if (!vfs_path_element_valid (path_element))
 443         return VFSF_UNKNOWN;
 444
 445     return path_element->class->flags;
 446 }
 447
 448 /* --------------------------------------------------------------------------------------------- */
 449
 450 void
 451 vfs_init (void)
 452 {
 453     /* create the VFS handle arrays */
 454     vfs__classes_list = g_ptr_array_new ();
 455
 456     /* create the VFS handle array */
 457     vfs_openfiles = g_ptr_array_new ();
 458
 459     vfs_str_buffer = g_string_new ("");
 460
 461 }
 462
 463 /* --------------------------------------------------------------------------------------------- */
 464
 465 void
 466 vfs_setup_work_dir (void)
 467 {
 468     const vfs_path_element_t *path_element;
 469
 470     vfs_setup_cwd ();
 471
 472     /* FIXME: is we really need for this check? */
 473     /*
 474        if (strlen (current_dir) > MC_MAXPATHLEN - 2)
 475        vfs_die ("Current dir too long.\n");
 476      */
 477
 478     path_element = vfs_path_get_by_index (current_path, -1);
 479     current_vfs = path_element->class;
 480 }
 481
 482 /* --------------------------------------------------------------------------------------------- */
 483
 484 void
 485 vfs_shut (void)
 486 {
 487     guint i;
 488
 489     vfs_gc_done ();
 490
 491     vfs_set_raw_current_dir (NULL);
 492
 493     for (i = 0; i < vfs__classes_list->len; i++)
 494     {
 495         struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
 496
 497         if (vfs->done != NULL)
 498             vfs->done (vfs);
 499     }
 500
 501     /* NULL-ize pointers to make unit tests happy */
 502     g_ptr_array_free (vfs_openfiles, TRUE);
 503     vfs_openfiles = NULL;
 504     g_ptr_array_free (vfs__classes_list, TRUE);
 505     vfs__classes_list = NULL;
 506     g_string_free (vfs_str_buffer, TRUE);
 507     vfs_str_buffer = NULL;
 508     current_vfs = NULL;
 509     vfs_free_handle_list = -1;
 510     MC_PTR_FREE (mc_readdir_result);
 511 }
 512
 513 /* --------------------------------------------------------------------------------------------- */
 514 /**
 515  * These ones grab information from the VFS
 516  *  and handles them to an upper layer
 517  */
 518
 519 void
 520 vfs_fill_names (fill_names_f func)
 521 {
 522     guint i;
 523
 524     for (i = 0; i < vfs__classes_list->len; i++)
 525     {
 526         struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
 527
 528         if (vfs->fill_names != NULL)
 529             vfs->fill_names (vfs, func);
 530     }
 531 }
 532
 533 /* --------------------------------------------------------------------------------------------- */
 534 gboolean
 535 vfs_file_is_local (const vfs_path_t * vpath)
 536 {
 537     return (vfs_file_class_flags (vpath) & VFSF_LOCAL) != 0;
 538 }
 539
 540 /* --------------------------------------------------------------------------------------------- */
 541
 542 void
 543 vfs_print_message (const char *msg, ...)
 544 {
 545     ev_vfs_print_message_t event_data;
 546     va_list ap;
 547
 548     va_start (ap, msg);
 549     event_data.msg = g_strdup_vprintf (msg, ap);
 550     va_end (ap);
 551
 552     mc_event_raise (MCEVENT_GROUP_CORE, "vfs_print_message", (gpointer) & event_data);
 553 }
 554
 555 /* --------------------------------------------------------------------------------------------- */
 556 /**
 557  * If it's local, reread the current directory
 558  * from the OS.
 559  */
 560
 561 void
 562 vfs_setup_cwd (void)
 563 {
 564     char *current_dir;
 565     vfs_path_t *tmp_vpath;
 566     const vfs_path_element_t *path_element;
 567
 568     if (vfs_get_raw_current_dir () == NULL)
 569     {
 570         current_dir = g_get_current_dir ();
 571         vfs_set_raw_current_dir (vfs_path_from_str (current_dir));
 572         g_free (current_dir);
 573
 574         current_dir = getenv ("PWD");
 575         tmp_vpath = vfs_path_from_str (current_dir);
 576
 577         if (tmp_vpath != NULL)
 578         {
 579             if (vfs_test_current_dir (tmp_vpath))
 580                 vfs_set_raw_current_dir (tmp_vpath);
 581             else
 582                 vfs_path_free (tmp_vpath);
 583         }
 584     }
 585
 586     path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
 587
 588     if ((path_element->class->flags & VFSF_LOCAL) != 0)
 589     {
 590         current_dir = g_get_current_dir ();
 591         tmp_vpath = vfs_path_from_str (current_dir);
 592         g_free (current_dir);
 593
 594         if (tmp_vpath != NULL)
 595         {
 596             /* One of directories in the path is not readable */
 597
 598             /* Check if it is O.K. to use the current_dir */
 599             if (!vfs_test_current_dir (tmp_vpath))
 600                 vfs_set_raw_current_dir (tmp_vpath);
 601             else
 602                 vfs_path_free (tmp_vpath);
 603         }
 604     }
 605 }
 606
 607 /* --------------------------------------------------------------------------------------------- */
 608 /**
 609  * Return current directory.  If it's local, reread the current directory
 610  * from the OS.
 611  */
 612
 613 char *
 614 _vfs_get_cwd (void)
 615 {
 616     const vfs_path_t *current_dir_vpath;
 617
 618     vfs_setup_cwd ();
 619     current_dir_vpath = vfs_get_raw_current_dir ();
 620     return g_strdup (vfs_path_as_str (current_dir_vpath));
 621 }
 622
 623 /* --------------------------------------------------------------------------------------------- */
 624 /**
 625  * Preallocate space for file in new place for ensure that file
 626  * will be fully copied with less fragmentation.
 627  *
 628  * @param dest_vfs_fd mc VFS file handler
 629  * @param src_fsize source file size
 630  * @param dest_fsize destination file size (if destination exists, otherwise should be 0)
 631  *
 632  * @return 0 if success and non-zero otherwise.
 633  * Note: function doesn't touch errno global variable.
 634  */
 635
 636 int
 637 vfs_preallocate (int dest_vfs_fd, off_t src_fsize, off_t dest_fsize)
 638 {
 639 #ifndef HAVE_POSIX_FALLOCATE
 640     (void) dest_vfs_fd;
 641     (void) src_fsize;
 642     (void) dest_fsize;
 643     return 0;
 644
 645 #else /* HAVE_POSIX_FALLOCATE */
 646     void *dest_fd = NULL;
 647     struct vfs_class *dest_class;
 648
 649     if (src_fsize == 0)
 650         return 0;
 651
 652     dest_class = vfs_class_find_by_handle (dest_vfs_fd, &dest_fd);
 653     if ((dest_class->flags & VFSF_LOCAL) == 0 || dest_fd == NULL)
 654         return 0;
 655
 656     return posix_fallocate (*(int *) dest_fd, dest_fsize, src_fsize - dest_fsize);
 657
 658 #endif /* HAVE_POSIX_FALLOCATE */
 659 }
 660
 661  /* --------------------------------------------------------------------------------------------- */
 662
 663 int
 664 vfs_clone_file (int dest_vfs_fd, int src_vfs_fd)
 665 {
 666 #ifdef FICLONE
 667     void *dest_fd = NULL;
 668     void *src_fd = NULL;
 669     struct vfs_class *dest_class;
 670     struct vfs_class *src_class;
 671
 672     dest_class = vfs_class_find_by_handle (dest_vfs_fd, &dest_fd);
 673     if ((dest_class->flags & VFSF_LOCAL) == 0)
 674     {
 675         errno = EOPNOTSUPP;
 676         return (-1);
 677     }
 678     if (dest_fd == NULL)
 679     {
 680         errno = EBADF;
 681         return (-1);
 682     }
 683
 684     src_class = vfs_class_find_by_handle (src_vfs_fd, &src_fd);
 685     if ((src_class->flags & VFSF_LOCAL) == 0)
 686     {
 687         errno = EOPNOTSUPP;
 688         return (-1);
 689     }
 690     if (src_fd == NULL)
 691     {
 692         errno = EBADF;
 693         return (-1);
 694     }
 695
 696     return ioctl (*(int *) dest_fd, FICLONE, *(int *) src_fd);
 697 #else
 698     (void) dest_vfs_fd;
 699     (void) src_vfs_fd;
 700     errno = EOPNOTSUPP;
 701     return (-1);
 702 #endif
 703 }
 704
 705 /* --------------------------------------------------------------------------------------------- */