lib/vfs/vfs.c

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