lib/vfs/vfs.c

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