lib/vfs/path.c

   1 /*
   2    Virtual File System path handlers
   3
   4    Copyright (C) 2011
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Slava Zanko <slavazanko@gmail.com>, 2011
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 /**
  27  * \file
  28  * \brief Source: Virtual File System: path handlers
  29  * \author Slava Zanko
  30  * \date 2011
  31  */
  32
  33
  34 #include <config.h>
  35
  36 #include "lib/global.h"
  37 #include "lib/strutil.h"
  38 #include "lib/util.h"           /* concat_dir_and_file */
  39 #include "lib/serialize.h"
  40
  41 #include "vfs.h"
  42 #include "utilvfs.h"
  43 #include "xdirentry.h"
  44 #include "path.h"
  45
  46 extern GPtrArray *vfs__classes_list;
  47
  48 /*** global variables ****************************************************************************/
  49
  50 /*** file scope macro definitions ****************************************************************/
  51
  52 /*** file scope type declarations ****************************************************************/
  53
  54 /*** file scope variables ************************************************************************/
  55
  56 /*** file scope functions ************************************************************************/
  57 /* --------------------------------------------------------------------------------------------- */
  58
  59 static gboolean
  60 path_magic (const char *path)
  61 {
  62     struct stat buf;
  63
  64     return (stat (path, &buf) != 0);
  65 }
  66
  67 /* --------------------------------------------------------------------------------------------- */
  68
  69 /**
  70  * Splits path extracting vfs part.
  71  *
  72  * Splits path
  73  * \verbatim /p1#op/inpath \endverbatim
  74  * into
  75  * \verbatim inpath,op; \endverbatim
  76  * returns which vfs it is.
  77  * What is left in path is p1. You still want to g_free(path), you DON'T
  78  * want to free neither *inpath nor *op
  79  */
  80
  81 static struct vfs_class *
  82 _vfs_split_with_semi_skip_count (char *path, const char **inpath, const char **op,
  83                                  size_t skip_count)
  84 {
  85     char *semi;
  86     char *slash;
  87     struct vfs_class *ret;
  88
  89     if (path == NULL)
  90         vfs_die ("Cannot split NULL");
  91
  92     semi = strrstr_skip_count (path, "#", skip_count);
  93
  94     if ((semi == NULL) || (!path_magic (path)))
  95         return NULL;
  96
  97     slash = strchr (semi, PATH_SEP);
  98     *semi = '\0';
  99
 100     if (op != NULL)
 101         *op = NULL;
 102
 103     if (inpath != NULL)
 104         *inpath = NULL;
 105
 106     if (slash != NULL)
 107         *slash = '\0';
 108
 109     ret = vfs_prefix_to_class (semi + 1);
 110     if (ret != NULL)
 111     {
 112         if (op != NULL)
 113             *op = semi + 1;
 114         if (inpath != NULL)
 115             *inpath = slash != NULL ? slash + 1 : NULL;
 116         return ret;
 117     }
 118
 119     if (slash != NULL)
 120         *slash = PATH_SEP;
 121
 122     *semi = '#';
 123     ret = _vfs_split_with_semi_skip_count (path, inpath, op, skip_count + 1);
 124     return ret;
 125 }
 126
 127 /* --------------------------------------------------------------------------------------------- */
 128 /**
 129  * remove //, /./ and /../
 130  *
 131  * @return newly allocated string
 132  */
 133
 134 static char *
 135 vfs_canon (const char *path)
 136 {
 137     if (!path)
 138         vfs_die ("Cannot canonicalize NULL");
 139
 140     /* Relative to current directory */
 141     if (*path != PATH_SEP)
 142     {
 143         char *local, *result, *curr_dir;
 144
 145         curr_dir = vfs_get_current_dir ();
 146         local = concat_dir_and_file (curr_dir, path);
 147         g_free (curr_dir);
 148
 149         result = vfs_canon (local);
 150         g_free (local);
 151         return result;
 152     }
 153
 154     /*
 155      * So we have path of following form:
 156      * /p1/p2#op/.././././p3#op/p4. Good luck.
 157      */
 158     {
 159         char *result = g_strdup (path);
 160         canonicalize_pathname (result);
 161         return result;
 162     }
 163 }
 164
 165 /* --------------------------------------------------------------------------------------------- */
 166 /**
 167  * Build URL parameters (such as user:pass@host:port) from one path element object
 168  *
 169  * @param element path element
 170  *
 171  * @return newly allocated string
 172  */
 173
 174 static char *
 175 vfs_path_build_url_params_str (vfs_path_element_t * element)
 176 {
 177     GString *buffer;
 178
 179     if (element == NULL)
 180         return NULL;
 181
 182     buffer = g_string_new ("");
 183
 184     if (element->user != NULL)
 185         g_string_append (buffer, element->user);
 186
 187     if (element->password != NULL)
 188     {
 189         g_string_append_c (buffer, ':');
 190         g_string_append (buffer, element->password);
 191     }
 192
 193     if (element->host != NULL)
 194     {
 195         if ((element->user != NULL) || (element->password != NULL))
 196             g_string_append_c (buffer, '@');
 197         if (element->ipv6)
 198             g_string_append_c (buffer, '[');
 199         g_string_append (buffer, element->host);
 200         if (element->ipv6)
 201             g_string_append_c (buffer, ']');
 202     }
 203
 204     if ((element->port) != 0 && (element->host != NULL))
 205     {
 206         g_string_append_c (buffer, ':');
 207         g_string_append_printf (buffer, "%d", element->port);
 208     }
 209
 210     return g_string_free (buffer, FALSE);
 211 }
 212
 213 /* --------------------------------------------------------------------------------------------- */
 214 /** get encoding after last #enc: or NULL, if part does not contain #enc:
 215  *
 216  * @param path string
 217  *
 218  * @return newly allocated string.
 219  */
 220
 221 static char *
 222 vfs_get_encoding (const char *path)
 223 {
 224     char result[16];
 225     char *work;
 226     char *semi;
 227     char *slash;
 228     work = g_strdup (path);
 229
 230     /* try found #enc: */
 231     semi = g_strrstr (work, VFS_ENCODING_PREFIX);
 232
 233     if (semi != NULL && (semi == work || *(semi - 1) == PATH_SEP))
 234     {
 235         semi += strlen (VFS_ENCODING_PREFIX);   /* skip "#enc:" */
 236         slash = strchr (semi, PATH_SEP);
 237         if (slash != NULL)
 238             slash[0] = '\0';
 239
 240         g_strlcpy (result, semi, sizeof (result));
 241         g_free (work);
 242         return g_strdup (result);
 243     }
 244     else
 245     {
 246         g_free (work);
 247         return NULL;
 248     }
 249 }
 250
 251 /* --------------------------------------------------------------------------------------------- */
 252 /**  Extract the hostname and username from the path
 253  *
 254  * Format of the path is [user@]hostname:port/remote-dir, e.g.:
 255  *
 256  * ftp://sunsite.unc.edu/pub/linux
 257  * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
 258  * ftp://tsx-11.mit.edu:8192/
 259  * ftp://joe@foo.edu:11321/private
 260  * ftp://joe:password@foo.se
 261  *
 262  * @param path_element is an input string to be parsed
 263  * @param path is an input string to be parsed
 264  *
 265  * @return g_malloc()ed url info.
 266  *         If the user is empty, e.g. ftp://@roxanne/private, and URL_USE_ANONYMOUS
 267  *         is not set, then the current login name is supplied.
 268  *         Return value is a g_malloc()ed structure with the pathname relative to the
 269  *         host.
 270  */
 271
 272 static void
 273 vfs_path_url_split (vfs_path_element_t * path_element, const char *path)
 274 {
 275     char *pcopy;
 276     const char *pend;
 277     char *dir, *colon, *inner_colon, *at, *rest;
 278
 279     path_element->port = 0;
 280
 281     pcopy = g_strdup (path);
 282     pend = pcopy + strlen (pcopy);
 283     dir = pcopy;
 284
 285     /* search for any possible user */
 286     at = strrchr (pcopy, '@');
 287
 288     /* We have a username */
 289     if (at == NULL)
 290         rest = pcopy;
 291     else
 292     {
 293         *at = '\0';
 294         inner_colon = strchr (pcopy, ':');
 295         if (inner_colon != NULL)
 296         {
 297             *inner_colon = '\0';
 298             inner_colon++;
 299             path_element->password = g_strdup (inner_colon);
 300         }
 301
 302         if (*pcopy != '\0')
 303             path_element->user = g_strdup (pcopy);
 304
 305         if (pend == at + 1)
 306             rest = at;
 307         else
 308             rest = at + 1;
 309     }
 310
 311     /* Check if the host comes with a port spec, if so, chop it */
 312     if (*rest != '[')
 313         colon = strchr (rest, ':');
 314     else
 315     {
 316         colon = strchr (++rest, ']');
 317         if (colon != NULL)
 318         {
 319             colon[0] = '\0';
 320             colon[1] = '\0';
 321             colon++;
 322             path_element->ipv6 = TRUE;
 323         }
 324     }
 325
 326     if (colon != NULL)
 327     {
 328         *colon = '\0';
 329         if (sscanf (colon + 1, "%d", &path_element->port) == 1)
 330         {
 331             if (path_element->port <= 0 || path_element->port >= 65536)
 332                 path_element->port = 0;
 333         }
 334         else
 335             while (*(++colon) != '\0')
 336             {
 337                 switch (*colon)
 338                 {
 339                 case 'C':
 340                     path_element->port = 1;
 341                     break;
 342                 case 'r':
 343                     path_element->port = 2;
 344                     break;
 345                 }
 346             }
 347     }
 348     path_element->host = g_strdup (rest);
 349     g_free (pcopy);
 350 }
 351
 352 /* --------------------------------------------------------------------------------------------- */
 353 /**
 354  * get VFS class for the given name
 355  *
 356  * @param class_name name of class
 357  *
 358  * @return pointer to class structure or NULL if class not found
 359  */
 360
 361 static struct vfs_class *
 362 vfs_get_class_by_name (const char *class_name)
 363 {
 364     guint i;
 365
 366     if (class_name == NULL)
 367         return NULL;
 368
 369     for (i = 0; i < vfs__classes_list->len; i++)
 370     {
 371         struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
 372         if ((vfs->name != NULL) && (strcmp (vfs->name, class_name) == 0))
 373             return vfs;
 374     }
 375
 376     return NULL;
 377 }
 378
 379 /* --------------------------------------------------------------------------------------------- */
 380 /**
 381  * Check if path string contain URL-like elements
 382  *
 383  * @param path_str path
 384  *
 385  * @return TRUE if path is deprecated or FALSE otherwise
 386  */
 387
 388 static gboolean
 389 vfs_path_is_str_path_deprecated (const char *path_str)
 390 {
 391     return strstr (path_str, VFS_PATH_URL_DELIMITER) == NULL;
 392 }
 393
 394 /* --------------------------------------------------------------------------------------------- */
 395 /** Split path string to path elements by deprecated algorithm.
 396  *
 397  * @param path_str VFS-path
 398  *
 399  * @return pointer to newly created vfs_path_t object with filled path elements array.
 400 */
 401
 402 static vfs_path_t *
 403 vfs_path_from_str_deprecated_parser (char *path)
 404 {
 405     vfs_path_t *vpath;
 406     vfs_path_element_t *element;
 407     struct vfs_class *class;
 408     const char *local, *op;
 409
 410     vpath = vfs_path_new ();
 411
 412     while ((class = _vfs_split_with_semi_skip_count (path, &local, &op, 0)) != NULL)
 413     {
 414         char *url_params;
 415         element = g_new0 (vfs_path_element_t, 1);
 416         element->class = class;
 417         if (local == NULL)
 418             local = "";
 419         element->path = vfs_translate_path_n (local);
 420
 421         element->encoding = vfs_get_encoding (local);
 422         element->dir.converter =
 423             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 424
 425         url_params = strchr (op, ':');  /* skip VFS prefix */
 426         if (url_params != NULL)
 427         {
 428             *url_params = '\0';
 429             url_params++;
 430             vfs_path_url_split (element, url_params);
 431         }
 432
 433         if (*op != '\0')
 434             element->vfs_prefix = g_strdup (op);
 435
 436         vpath->path = g_list_prepend (vpath->path, element);
 437     }
 438     if (path[0] != '\0')
 439     {
 440         element = g_new0 (vfs_path_element_t, 1);
 441         element->class = g_ptr_array_index (vfs__classes_list, 0);
 442         element->path = vfs_translate_path_n (path);
 443
 444         element->encoding = vfs_get_encoding (path);
 445         element->dir.converter =
 446             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 447         vpath->path = g_list_prepend (vpath->path, element);
 448     }
 449
 450     return vpath;
 451 }
 452
 453 /* --------------------------------------------------------------------------------------------- */
 454 /** Split path string to path elements by URL algorithm.
 455  *
 456  * @param path_str VFS-path
 457  *
 458  * @return pointer to newly created vfs_path_t object with filled path elements array.
 459 */
 460
 461 static vfs_path_t *
 462 vfs_path_from_str_uri_parser (char *path)
 463 {
 464     vfs_path_t *vpath;
 465     vfs_path_element_t *element;
 466
 467     char *url_delimiter;
 468
 469     vpath = vfs_path_new ();
 470
 471     while ((url_delimiter = g_strrstr (path, VFS_PATH_URL_DELIMITER)) != NULL)
 472     {
 473         char *vfs_prefix_start;
 474         char *real_vfs_prefix_start = url_delimiter;
 475         char *slash_pointer;
 476         struct vfs_s_subclass *sub = NULL;
 477
 478         while (real_vfs_prefix_start > path && *(real_vfs_prefix_start) != PATH_SEP)
 479             real_vfs_prefix_start--;
 480         vfs_prefix_start = real_vfs_prefix_start;
 481
 482         if (*(vfs_prefix_start) == PATH_SEP)
 483             vfs_prefix_start += 1;
 484
 485         *url_delimiter = '\0';
 486
 487         element = g_new0 (vfs_path_element_t, 1);
 488         element->class = vfs_prefix_to_class (vfs_prefix_start);
 489         element->vfs_prefix = g_strdup (vfs_prefix_start);
 490
 491         url_delimiter += strlen (VFS_PATH_URL_DELIMITER);
 492         sub = VFSDATA (element);
 493         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 494         {
 495             slash_pointer = strchr (url_delimiter, PATH_SEP);
 496             if (slash_pointer == NULL)
 497             {
 498                 element->path = g_strdup ("");
 499             }
 500             else
 501             {
 502                 element->path = vfs_translate_path_n (slash_pointer + 1);
 503                 element->encoding = vfs_get_encoding (slash_pointer);
 504
 505                 *slash_pointer = '\0';
 506             }
 507             vfs_path_url_split (element, url_delimiter);
 508         }
 509         else
 510         {
 511             element->path = vfs_translate_path_n (url_delimiter);
 512             element->encoding = vfs_get_encoding (url_delimiter);
 513         }
 514         element->dir.converter =
 515             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 516         vpath->path = g_list_prepend (vpath->path, element);
 517
 518         if ((real_vfs_prefix_start > path && *(real_vfs_prefix_start) == PATH_SEP) ||
 519             (real_vfs_prefix_start == path && *(real_vfs_prefix_start) != PATH_SEP))
 520             *real_vfs_prefix_start = '\0';
 521         else
 522             *(real_vfs_prefix_start + 1) = '\0';
 523     }
 524
 525     if (path[0] != '\0')
 526     {
 527         element = g_new0 (vfs_path_element_t, 1);
 528         element->class = g_ptr_array_index (vfs__classes_list, 0);
 529         element->path = vfs_translate_path_n (path);
 530         element->encoding = vfs_get_encoding (path);
 531         element->dir.converter =
 532             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 533         vpath->path = g_list_prepend (vpath->path, element);
 534     }
 535
 536     return vpath;
 537 }
 538
 539 /* --------------------------------------------------------------------------------------------- */
 540 /**
 541  * Add element's class info to result string (such as VFS name, host, encoding etc)
 542  * This function used as helper only in vfs_path_tokens_get() function
 543  *
 544  * @param element current path element
 545  * @param ret_tokens total tikens for return
 546  * @param element_tokens accumulated element-only tokens
 547  */
 548
 549 static void
 550 vfs_path_tokens_add_class_info (vfs_path_element_t * element, GString * ret_tokens,
 551                                     GString * element_tokens)
 552 {
 553     if (((element->class->flags & VFSF_LOCAL) == 0 || ret_tokens->len > 0)
 554         && element_tokens->len > 0)
 555     {
 556         char *url_str;
 557
 558         if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP)
 559             g_string_append_c (ret_tokens, PATH_SEP);
 560
 561         g_string_append (ret_tokens, element->vfs_prefix);
 562         g_string_append (ret_tokens, VFS_PATH_URL_DELIMITER);
 563
 564         url_str = vfs_path_build_url_params_str (element);
 565         if (*url_str != '\0')
 566         {
 567             g_string_append (ret_tokens, url_str);
 568             g_string_append_c (ret_tokens, PATH_SEP);
 569         }
 570
 571         g_free (url_str);
 572     }
 573     if (element->encoding != NULL)
 574     {
 575         if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP)
 576             g_string_append (ret_tokens, PATH_SEP_STR);
 577         g_string_append (ret_tokens, VFS_ENCODING_PREFIX);
 578         g_string_append (ret_tokens, element->encoding);
 579         g_string_append (ret_tokens, PATH_SEP_STR);
 580     }
 581
 582     g_string_append (ret_tokens, element_tokens->str);
 583 }
 584
 585 /* --------------------------------------------------------------------------------------------- */
 586 /*** public functions ****************************************************************************/
 587 /* --------------------------------------------------------------------------------------------- */
 588 /**
 589  * Convert first elements_count elements from vfs_path_t to string representation.
 590  *
 591  * @param vpath pointer to vfs_path_t object
 592  * @param elements_count count of first elements for convert
 593  * @param flags flags for parser
 594  *
 595  * @return pointer to newly created string.
 596  */
 597
 598 #define vfs_append_from_path(appendfrom) \
 599 { \
 600     if ((*appendfrom != PATH_SEP) && (*appendfrom != '\0') \
 601         && (buffer->str[buffer->len - 1] != PATH_SEP)) \
 602         g_string_append_c (buffer, PATH_SEP); \
 603     g_string_append (buffer, appendfrom); \
 604 }
 605
 606 char *
 607 vfs_path_to_str_elements_count (const vfs_path_t * vpath, int elements_count)
 608 {
 609     int element_index;
 610     GString *buffer;
 611     GString *recode_buffer;
 612
 613     if (vpath == NULL)
 614         return NULL;
 615
 616     if (elements_count > vfs_path_elements_count (vpath))
 617         elements_count = vfs_path_elements_count (vpath);
 618
 619     if (elements_count < 0)
 620         elements_count = vfs_path_elements_count (vpath) + elements_count;
 621
 622     buffer = g_string_new ("");
 623     recode_buffer = g_string_new ("");
 624
 625     for (element_index = 0; element_index < elements_count; element_index++)
 626     {
 627         vfs_path_element_t *element = vfs_path_get_by_index (vpath, element_index);
 628
 629         if (element->vfs_prefix != NULL)
 630         {
 631             char *url_str;
 632
 633             if (buffer->len == 0 || buffer->str[buffer->len - 1] != PATH_SEP)
 634                 g_string_append_c (buffer, PATH_SEP);
 635
 636             g_string_append (buffer, element->vfs_prefix);
 637             g_string_append (buffer, VFS_PATH_URL_DELIMITER);
 638
 639             url_str = vfs_path_build_url_params_str (element);
 640             if (*url_str != '\0')
 641                 g_string_append (buffer, url_str);
 642
 643             g_free (url_str);
 644         }
 645
 646         if (vfs_path_element_need_cleanup_converter (element))
 647         {
 648             if (buffer->str[buffer->len - 1] != PATH_SEP)
 649                 g_string_append (buffer, PATH_SEP_STR);
 650             g_string_append (buffer, VFS_ENCODING_PREFIX);
 651             g_string_append (buffer, element->encoding);
 652             str_vfs_convert_from (element->dir.converter, element->path, recode_buffer);
 653             vfs_append_from_path (recode_buffer->str);
 654             g_string_set_size (recode_buffer, 0);
 655         }
 656         else
 657         {
 658             vfs_append_from_path (element->path);
 659         }
 660     }
 661     g_string_free (recode_buffer, TRUE);
 662     return g_string_free (buffer, FALSE);
 663 }
 664
 665 #undef vfs_append_from_path
 666
 667 /* --------------------------------------------------------------------------------------------- */
 668 /**
 669  * Convert vfs_path_t to string representation.
 670  *
 671  * @param vpath pointer to vfs_path_t object
 672  *
 673  * @return pointer to newly created string.
 674  */
 675
 676 char *
 677 vfs_path_to_str (const vfs_path_t * vpath)
 678 {
 679     return vfs_path_to_str_elements_count (vpath, vfs_path_elements_count (vpath));
 680 }
 681
 682 /* --------------------------------------------------------------------------------------------- */
 683 /**
 684  * Split path string to path elements with flags for change parce process.
 685  *
 686  * @param path_str VFS-path
 687  * @param flags flags for parser
 688  *
 689  * @return pointer to newly created vfs_path_t object with filled path elements array.
 690  */
 691
 692 vfs_path_t *
 693 vfs_path_from_str_flags (const char *path_str, vfs_path_flag_t flags)
 694 {
 695     vfs_path_t *vpath;
 696     char *path;
 697
 698     if (path_str == NULL)
 699         return NULL;
 700
 701     if ((flags & VPF_NO_CANON) == 0)
 702         path = vfs_canon (path_str);
 703     else
 704         path = g_strdup (path_str);
 705
 706     if (path == NULL)
 707         return NULL;
 708
 709     if ((flags & VPF_USE_DEPRECATED_PARSER) != 0 && vfs_path_is_str_path_deprecated (path))
 710         vpath = vfs_path_from_str_deprecated_parser (path);
 711     else
 712         vpath = vfs_path_from_str_uri_parser (path);
 713
 714     g_free (path);
 715
 716     return vpath;
 717 }
 718
 719 /* --------------------------------------------------------------------------------------------- */
 720 /**
 721  * Split path string to path elements.
 722  *
 723  * @param path_str VFS-path
 724  *
 725  * @return pointer to newly created vfs_path_t object with filled path elements array.
 726  */
 727
 728 vfs_path_t *
 729 vfs_path_from_str (const char *path_str)
 730 {
 731     return vfs_path_from_str_flags (path_str, VPF_NONE);
 732 }
 733
 734 /* --------------------------------------------------------------------------------------------- */
 735 /*
 736  * Create new vfs_path_t object.
 737  *
 738  * @return pointer to newly created vfs_path_t object.
 739  */
 740
 741 vfs_path_t *
 742 vfs_path_new (void)
 743 {
 744     vfs_path_t *vpath;
 745     vpath = g_new0 (vfs_path_t, 1);
 746     return vpath;
 747 }
 748
 749 /* --------------------------------------------------------------------------------------------- */
 750 /*
 751  * Get count of path elements.
 752  *
 753  * @param vpath pointer to vfs_path_t object
 754  *
 755  * @return count of path elements.
 756  */
 757
 758 int
 759 vfs_path_elements_count (const vfs_path_t * vpath)
 760 {
 761     return (vpath != NULL && vpath->path != NULL) ? g_list_length (vpath->path) : 0;
 762 }
 763
 764 /* --------------------------------------------------------------------------------------------- */
 765 /*
 766  * Get one path element by index.
 767  *
 768  * @param vpath pointer to vfs_path_t object
 769  * @param element_index element index. May have negative value (in this case count was started at the end of list).
 770  *
 771  * @return path element.
 772  */
 773
 774 vfs_path_element_t *
 775 vfs_path_get_by_index (const vfs_path_t * vpath, int element_index)
 776 {
 777     if (element_index < 0)
 778         element_index += vfs_path_elements_count (vpath);
 779
 780     if (element_index < 0)
 781         vfs_die ("vfs_path_get_by_index: incorrect index!");
 782
 783     return g_list_nth_data (vpath->path, element_index);
 784 }
 785
 786 /* --------------------------------------------------------------------------------------------- */
 787 /*
 788  * Clone one path element
 789  *
 790  * @param element pointer to vfs_path_element_t object
 791  *
 792  * @return Newly allocated path element
 793  */
 794
 795 vfs_path_element_t *
 796 vfs_path_element_clone (const vfs_path_element_t * element)
 797 {
 798     vfs_path_element_t *new_element = g_new0 (vfs_path_element_t, 1);
 799     memcpy (new_element, element, sizeof (vfs_path_element_t));
 800
 801     new_element->user = g_strdup (element->user);
 802     new_element->password = g_strdup (element->password);
 803     new_element->host = g_strdup (element->host);
 804     new_element->path = g_strdup (element->path);
 805     new_element->encoding = g_strdup (element->encoding);
 806     if (vfs_path_element_need_cleanup_converter (element) && new_element->encoding != NULL)
 807         new_element->dir.converter = str_crt_conv_from (new_element->encoding);
 808     new_element->vfs_prefix = g_strdup (element->vfs_prefix);
 809
 810     return new_element;
 811 }
 812
 813 /* --------------------------------------------------------------------------------------------- */
 814 /*
 815  * Free one path element.
 816  *
 817  * @param element pointer to vfs_path_element_t object
 818  *
 819  */
 820
 821 void
 822 vfs_path_element_free (vfs_path_element_t * element)
 823 {
 824     if (element == NULL)
 825         return;
 826
 827     g_free (element->user);
 828     g_free (element->password);
 829     g_free (element->host);
 830     g_free (element->path);
 831     g_free (element->encoding);
 832     g_free (element->vfs_prefix);
 833
 834     if (vfs_path_element_need_cleanup_converter (element))
 835     {
 836         str_close_conv (element->dir.converter);
 837     }
 838
 839     g_free (element);
 840 }
 841
 842 /* --------------------------------------------------------------------------------------------- */
 843 /*
 844  * Clone path
 845  *
 846  * @param vpath pointer to vfs_path_t object
 847  *
 848  * @return Newly allocated path object
 849  */
 850
 851 vfs_path_t *
 852 vfs_path_clone (const vfs_path_t * vpath)
 853 {
 854     vfs_path_t *new_vpath;
 855     int vpath_element_index;
 856     if (vpath == NULL)
 857         return NULL;
 858
 859     new_vpath = vfs_path_new ();
 860     for (vpath_element_index = 0; vpath_element_index < vfs_path_elements_count (vpath);
 861          vpath_element_index++)
 862     {
 863         new_vpath->path =
 864             g_list_append (new_vpath->path,
 865                            vfs_path_element_clone (vfs_path_get_by_index
 866                                                    (vpath, vpath_element_index)));
 867     }
 868
 869     return new_vpath;
 870 }
 871
 872 /* --------------------------------------------------------------------------------------------- */
 873 /*
 874  * Free vfs_path_t object.
 875  *
 876  * @param vpath pointer to vfs_path_t object
 877  *
 878  */
 879
 880 void
 881 vfs_path_free (vfs_path_t * path)
 882 {
 883     if (path == NULL)
 884         return;
 885     g_list_foreach (path->path, (GFunc) vfs_path_element_free, NULL);
 886     g_list_free (path->path);
 887     g_free (path);
 888 }
 889
 890 /* --------------------------------------------------------------------------------------------- */
 891 /*
 892  * Remove one path element by index
 893  *
 894  * @param vpath pointer to vfs_path_t object
 895  * @param element_index element index. May have negative value (in this case count was started at the end of list).
 896  *
 897  */
 898
 899 void
 900 vfs_path_remove_element_by_index (vfs_path_t * vpath, int element_index)
 901 {
 902     vfs_path_element_t *element;
 903
 904     if ((vpath == NULL) || (vfs_path_elements_count (vpath) == 1))
 905         return;
 906
 907     if (element_index < 0)
 908         element_index = vfs_path_elements_count (vpath) + element_index;
 909
 910     element = g_list_nth_data (vpath->path, element_index);
 911     vpath->path = g_list_remove (vpath->path, element);
 912     vfs_path_element_free (element);
 913 }
 914
 915 /* --------------------------------------------------------------------------------------------- */
 916 /** Return VFS class for the given prefix */
 917
 918 struct vfs_class *
 919 vfs_prefix_to_class (const char *prefix)
 920 {
 921     guint i;
 922
 923     /* Avoid first class (localfs) that would accept any prefix */
 924     for (i = 1; i < vfs__classes_list->len; i++)
 925     {
 926         struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
 927         if (vfs->which != NULL)
 928         {
 929             if (vfs->which (vfs, prefix) == -1)
 930                 continue;
 931             return vfs;
 932         }
 933
 934         if (vfs->prefix != NULL && strncmp (prefix, vfs->prefix, strlen (vfs->prefix)) == 0)
 935             return vfs;
 936     }
 937
 938     return NULL;
 939 }
 940
 941 /* --------------------------------------------------------------------------------------------- */
 942 /**
 943  * Check if need cleanup charset converter for vfs_path_element_t
 944  *
 945  * @param element part of path
 946  *
 947  * @return TRUE if need cleanup converter or FALSE otherwise
 948  */
 949
 950 gboolean
 951 vfs_path_element_need_cleanup_converter (const vfs_path_element_t * element)
 952 {
 953     return (element->dir.converter != str_cnv_from_term && element->dir.converter != INVALID_CONV);
 954 }
 955
 956 /* --------------------------------------------------------------------------------------------- */
 957 /**
 958  * Serialize vfs_path_t object to string
 959  *
 960  * @param vpath data for serialization
 961  * @param error contain pointer to object for handle error code and message
 962  *
 963  * @return serialized vpath as newly allocated string
 964  */
 965
 966 char *
 967 vfs_path_serialize (const vfs_path_t * vpath, GError ** error)
 968 {
 969     mc_config_t *cpath = mc_config_init (NULL);
 970     ssize_t element_index;
 971     char *ret_value;
 972
 973     if ((vpath == NULL) || (vfs_path_elements_count (vpath) == 0))
 974     {
 975         g_set_error (error, MC_ERROR, -1, "vpath object is empty");
 976         return NULL;
 977
 978     }
 979     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
 980     {
 981         char *groupname = g_strdup_printf ("path-element-%zd", element_index);
 982         vfs_path_element_t *element = vfs_path_get_by_index (vpath, element_index);
 983
 984         /* convert one element to config group */
 985
 986         mc_config_set_string_raw (cpath, groupname, "path", element->path);
 987         mc_config_set_string_raw (cpath, groupname, "class-name", element->class->name);
 988         mc_config_set_string_raw (cpath, groupname, "encoding", element->encoding);
 989
 990         mc_config_set_string_raw (cpath, groupname, "vfs_prefix", element->vfs_prefix);
 991
 992         mc_config_set_string_raw (cpath, groupname, "user", element->user);
 993         mc_config_set_string_raw (cpath, groupname, "password", element->password);
 994         mc_config_set_string_raw (cpath, groupname, "host", element->host);
 995         if (element->port != 0)
 996             mc_config_set_int (cpath, groupname, "port", element->port);
 997
 998         g_free (groupname);
 999     }
1000
1001     ret_value = mc_serialize_config (cpath, error);
1002     mc_config_deinit (cpath);
1003     return ret_value;
1004 }
1005
1006 /* --------------------------------------------------------------------------------------------- */
1007 /**
1008  * Deserialize string to vfs_path_t object
1009  *
1010  * @param data data for serialization
1011  * @param error contain pointer to object for handle error code and message
1012  *
1013  * @return newly allocated vfs_path_t object
1014  */
1015
1016 vfs_path_t *
1017 vfs_path_deserialize (const char *data, GError ** error)
1018 {
1019     mc_config_t *cpath = mc_deserialize_config (data, error);
1020     size_t element_index = 0;
1021     vfs_path_t *vpath;
1022
1023     if (cpath == NULL)
1024         return NULL;
1025
1026     vpath = vfs_path_new ();
1027
1028     while (TRUE)
1029     {
1030         vfs_path_element_t *element;
1031         char *cfg_value;
1032         char *groupname;
1033
1034         groupname = g_strdup_printf ("path-element-%zd", element_index);
1035         if (!mc_config_has_group (cpath, groupname))
1036         {
1037             g_free (groupname);
1038             break;
1039         }
1040
1041         element = g_new0 (vfs_path_element_t, 1);
1042
1043         cfg_value = mc_config_get_string_raw (cpath, groupname, "class-name", NULL);
1044         element->class = vfs_get_class_by_name (cfg_value);
1045         if (element->class == NULL)
1046         {
1047             g_free (element);
1048             vfs_path_free (vpath);
1049             g_set_error (error, MC_ERROR, -1, "Unable to find VFS class by name '%s'", cfg_value);
1050             g_free (cfg_value);
1051             mc_config_deinit (cpath);
1052             return NULL;
1053         }
1054         g_free (cfg_value);
1055
1056         element->path = mc_config_get_string_raw (cpath, groupname, "path", NULL);
1057         element->encoding = mc_config_get_string_raw (cpath, groupname, "encoding", NULL);
1058         element->dir.converter =
1059             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
1060
1061         element->vfs_prefix = mc_config_get_string_raw (cpath, groupname, "vfs_prefix", NULL);
1062
1063         element->user = mc_config_get_string_raw (cpath, groupname, "user", NULL);
1064         element->password = mc_config_get_string_raw (cpath, groupname, "password", NULL);
1065         element->host = mc_config_get_string_raw (cpath, groupname, "host", NULL);
1066         element->port = mc_config_get_int (cpath, groupname, "port", 0);
1067
1068         vpath->path = g_list_append (vpath->path, element);
1069
1070         g_free (groupname);
1071         element_index++;
1072     }
1073
1074     mc_config_deinit (cpath);
1075     if (vfs_path_elements_count (vpath) == 0)
1076     {
1077         vfs_path_free (vpath);
1078         g_set_error (error, MC_ERROR, -1, "No any path elements found");
1079         return NULL;
1080     }
1081
1082     return vpath;
1083 }
1084
1085 /* --------------------------------------------------------------------------------------------- */
1086 /**
1087  * Build vfs_path_t object from arguments.
1088  *
1089  * @param ... path tokens, terminated by NULL
1090  *
1091  * @return newly allocated vfs_path_t object
1092  */
1093
1094 vfs_path_t *
1095 vfs_path_build_filename (const char *first_element, ...)
1096 {
1097     va_list args;
1098     char *str_path;
1099     vfs_path_t *vpath;
1100
1101     if (first_element == NULL)
1102         return NULL;
1103
1104     va_start (args, first_element);
1105     str_path = mc_build_filenamev (first_element, args);
1106     va_end (args);
1107     vpath = vfs_path_from_str (str_path);
1108     g_free (str_path);
1109     return vpath;
1110 }
1111
1112 /* --------------------------------------------------------------------------------------------- */
1113 /**
1114  * Append tokens to path object
1115  *
1116  * @param vpath path object
1117  * @param ... NULL-terminated strings
1118  *
1119  * @return newly allocated path object
1120  */
1121
1122 vfs_path_t *
1123 vfs_path_append_new (const vfs_path_t * vpath, const char *first_element, ...)
1124 {
1125     va_list args;
1126     char *str_path, *result_str;
1127     vfs_path_t *ret_vpath;
1128
1129     if (vpath == NULL || first_element == NULL)
1130         return NULL;
1131
1132     va_start (args, first_element);
1133     str_path = mc_build_filenamev (first_element, args);
1134     va_end (args);
1135
1136     result_str = vfs_path_to_str (vpath);
1137     ret_vpath = vfs_path_build_filename (result_str, str_path, NULL);
1138     g_free (result_str);
1139     g_free (str_path);
1140
1141     return ret_vpath;
1142
1143 }
1144
1145 /* --------------------------------------------------------------------------------------------- */
1146 /**
1147  * get tockens count in path.
1148  *
1149  * @param vpath path object
1150  *
1151  * @return count of tokens
1152  */
1153
1154 size_t
1155 vfs_path_tokens_count (const vfs_path_t * vpath)
1156 {
1157     size_t count_tokens = 0;
1158     int element_index;
1159
1160     if (vpath == NULL)
1161         return 0;
1162
1163     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
1164     {
1165         vfs_path_element_t *element;
1166         char **path_tokens, **iterator;
1167
1168         element = vfs_path_get_by_index (vpath, element_index);
1169         path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1);
1170
1171         while (*iterator != NULL)
1172         {
1173             if (**iterator != '\0')
1174                 count_tokens++;
1175             iterator++;
1176         }
1177         g_strfreev (path_tokens);
1178     }
1179     return count_tokens;
1180 }
1181
1182 /* --------------------------------------------------------------------------------------------- */
1183 /**
1184  * Get subpath by tokens
1185  *
1186  * @param vpath path object
1187  * @param start_position first token for got/ Started from 0.
1188  *        If negative, then position will be relative to end of path
1189  * @param length count of tokens
1190  *
1191  * @return newly allocated string with path tokens separated by slash
1192  */
1193
1194 char *
1195 vfs_path_tokens_get (const vfs_path_t * vpath, ssize_t start_position, size_t length)
1196 {
1197     GString *ret_tokens, *element_tokens;
1198     int element_index;
1199     size_t tokens_count = vfs_path_tokens_count (vpath);
1200
1201     if (length == 0)
1202         length = tokens_count;
1203
1204     if (start_position < 0)
1205         start_position = (ssize_t) tokens_count + start_position;
1206
1207     if (start_position < 0)
1208         return NULL;
1209
1210     if (start_position >= (ssize_t) tokens_count)
1211         return NULL;
1212
1213     if (start_position + (ssize_t) length > (ssize_t) tokens_count)
1214         length = tokens_count - start_position;
1215
1216     ret_tokens = g_string_sized_new (32);
1217     element_tokens = g_string_sized_new (32);
1218
1219     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
1220     {
1221         vfs_path_element_t *element;
1222         char **path_tokens, **iterator;
1223
1224         g_string_assign (element_tokens, "");
1225         element = vfs_path_get_by_index (vpath, element_index);
1226         path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1);
1227
1228         while (*iterator != NULL)
1229         {
1230             if (**iterator != '\0')
1231             {
1232                 if (start_position == 0)
1233                 {
1234                     if (length == 0)
1235                     {
1236                         vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens);
1237                         g_string_free (element_tokens, TRUE);
1238                         g_strfreev (path_tokens);
1239                         return g_string_free (ret_tokens, FALSE);
1240                     }
1241                     length--;
1242                     if (element_tokens->len != 0)
1243                         g_string_append_c (element_tokens, PATH_SEP);
1244                     g_string_append (element_tokens, *iterator);
1245                 }
1246                 else
1247                     start_position--;
1248             }
1249             iterator++;
1250         }
1251         g_strfreev (path_tokens);
1252         vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens);
1253     }
1254
1255     g_string_free (element_tokens, TRUE);
1256     return g_string_free (ret_tokens, !(start_position == 0 && length == 0));
1257 }
1258
1259 /* --------------------------------------------------------------------------------------------- */