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"           /* mc_build_filename() */
  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 == NULL)
 138         vfs_die ("Cannot canonicalize NULL");
 139
 140     /* Relative to current directory */
 141     if (*path != PATH_SEP)
 142     {
 143         char *result, *local;
 144
 145         if (g_str_has_prefix (path, VFS_ENCODING_PREFIX))
 146         {
 147             /*
 148                encoding prefix placed at start of string without the leading slash
 149                should be autofixed by adding the leading slash
 150              */
 151             local = mc_build_filename (PATH_SEP_STR, path, NULL);
 152         }
 153         else
 154         {
 155             char *curr_dir;
 156
 157             curr_dir = vfs_get_current_dir ();
 158             local = mc_build_filename (curr_dir, path, NULL);
 159             g_free (curr_dir);
 160         }
 161         result = vfs_canon (local);
 162         g_free (local);
 163         return result;
 164     }
 165
 166     /*
 167      * So we have path of following form:
 168      * /p1/p2#op/.././././p3#op/p4. Good luck.
 169      */
 170     {
 171         char *result;
 172
 173         result = g_strdup (path);
 174         canonicalize_pathname (result);
 175         return result;
 176     }
 177 }
 178
 179 /* --------------------------------------------------------------------------------------------- */
 180
 181 #ifdef HAVE_CHARSET
 182 /** get encoding after last #enc: or NULL, if part does not contain #enc:
 183  *
 184  * @param path string
 185  *
 186  * @return newly allocated string.
 187  */
 188
 189 static char *
 190 vfs_get_encoding (const char *path)
 191 {
 192     char result[16];
 193     char *work;
 194     char *semi;
 195     char *slash;
 196     work = g_strdup (path);
 197
 198     /* try found #enc: */
 199     semi = g_strrstr (work, VFS_ENCODING_PREFIX);
 200
 201     if (semi != NULL && (semi == work || *(semi - 1) == PATH_SEP))
 202     {
 203         semi += strlen (VFS_ENCODING_PREFIX);   /* skip "#enc:" */
 204         slash = strchr (semi, PATH_SEP);
 205         if (slash != NULL)
 206             slash[0] = '\0';
 207
 208         g_strlcpy (result, semi, sizeof (result));
 209         g_free (work);
 210         return g_strdup (result);
 211     }
 212     else
 213     {
 214         g_free (work);
 215         return NULL;
 216     }
 217 }
 218 #endif
 219
 220 /* --------------------------------------------------------------------------------------------- */
 221 /**  Extract the hostname and username from the path
 222  *
 223  * Format of the path is [user@]hostname:port/remote-dir, e.g.:
 224  *
 225  * ftp://sunsite.unc.edu/pub/linux
 226  * ftp://miguel@sphinx.nuclecu.unam.mx/c/nc
 227  * ftp://tsx-11.mit.edu:8192/
 228  * ftp://joe@foo.edu:11321/private
 229  * ftp://joe:password@foo.se
 230  *
 231  * @param path_element is an input string to be parsed
 232  * @param path is an input string to be parsed
 233  *
 234  * @return g_malloc()ed url info.
 235  *         If the user is empty, e.g. ftp://@roxanne/private, and URL_USE_ANONYMOUS
 236  *         is not set, then the current login name is supplied.
 237  *         Return value is a g_malloc()ed structure with the pathname relative to the
 238  *         host.
 239  */
 240
 241 static void
 242 vfs_path_url_split (vfs_path_element_t * path_element, const char *path)
 243 {
 244     char *pcopy;
 245     const char *pend;
 246     char *colon, *inner_colon, *at, *rest;
 247
 248     path_element->port = 0;
 249
 250     pcopy = g_strdup (path);
 251     pend = pcopy + strlen (pcopy);
 252
 253     /* search for any possible user */
 254     at = strrchr (pcopy, '@');
 255
 256     /* We have a username */
 257     if (at == NULL)
 258         rest = pcopy;
 259     else
 260     {
 261         *at = '\0';
 262         inner_colon = strchr (pcopy, ':');
 263         if (inner_colon != NULL)
 264         {
 265             *inner_colon = '\0';
 266             inner_colon++;
 267             path_element->password = g_strdup (inner_colon);
 268         }
 269
 270         if (*pcopy != '\0')
 271             path_element->user = g_strdup (pcopy);
 272
 273         if (pend == at + 1)
 274             rest = at;
 275         else
 276             rest = at + 1;
 277     }
 278
 279     /* Check if the host comes with a port spec, if so, chop it */
 280     if (*rest != '[')
 281         colon = strchr (rest, ':');
 282     else
 283     {
 284         colon = strchr (++rest, ']');
 285         if (colon != NULL)
 286         {
 287             colon[0] = '\0';
 288             colon[1] = '\0';
 289             colon++;
 290             path_element->ipv6 = TRUE;
 291         }
 292     }
 293
 294     if (colon != NULL)
 295     {
 296         *colon = '\0';
 297         if (sscanf (colon + 1, "%d", &path_element->port) == 1)
 298         {
 299             if (path_element->port <= 0 || path_element->port >= 65536)
 300                 path_element->port = 0;
 301         }
 302         else
 303             while (*(++colon) != '\0')
 304             {
 305                 switch (*colon)
 306                 {
 307                 case 'C':
 308                     path_element->port = 1;
 309                     break;
 310                 case 'r':
 311                     path_element->port = 2;
 312                     break;
 313                 }
 314             }
 315     }
 316     path_element->host = g_strdup (rest);
 317     g_free (pcopy);
 318 }
 319
 320 /* --------------------------------------------------------------------------------------------- */
 321 /**
 322  * get VFS class for the given name
 323  *
 324  * @param class_name name of class
 325  *
 326  * @return pointer to class structure or NULL if class not found
 327  */
 328
 329 static struct vfs_class *
 330 vfs_get_class_by_name (const char *class_name)
 331 {
 332     guint i;
 333
 334     if (class_name == NULL)
 335         return NULL;
 336
 337     for (i = 0; i < vfs__classes_list->len; i++)
 338     {
 339         struct vfs_class *vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
 340         if ((vfs->name != NULL) && (strcmp (vfs->name, class_name) == 0))
 341             return vfs;
 342     }
 343
 344     return NULL;
 345 }
 346
 347 /* --------------------------------------------------------------------------------------------- */
 348 /**
 349  * Check if path string contain URL-like elements
 350  *
 351  * @param path_str path
 352  *
 353  * @return TRUE if path is deprecated or FALSE otherwise
 354  */
 355
 356 static gboolean
 357 vfs_path_is_str_path_deprecated (const char *path_str)
 358 {
 359     return strstr (path_str, VFS_PATH_URL_DELIMITER) == NULL;
 360 }
 361
 362 /* --------------------------------------------------------------------------------------------- */
 363 /** Split path string to path elements by deprecated algorithm.
 364  *
 365  * @param path_str VFS-path
 366  *
 367  * @return pointer to newly created vfs_path_t object with filled path elements array.
 368 */
 369
 370 static vfs_path_t *
 371 vfs_path_from_str_deprecated_parser (char *path, vfs_path_flag_t flags)
 372 {
 373     vfs_path_t *vpath;
 374     vfs_path_element_t *element;
 375     struct vfs_class *class;
 376     const char *local, *op;
 377
 378     (void) flags;
 379     vpath = vfs_path_new ();
 380
 381     while ((class = _vfs_split_with_semi_skip_count (path, &local, &op, 0)) != NULL)
 382     {
 383         char *url_params;
 384         element = g_new0 (vfs_path_element_t, 1);
 385         element->class = class;
 386         if (local == NULL)
 387             local = "";
 388         element->path = vfs_translate_path_n (local);
 389
 390 #ifdef HAVE_CHARSET
 391         element->encoding = vfs_get_encoding (local);
 392         element->dir.converter =
 393             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 394 #endif
 395
 396         url_params = strchr (op, ':');  /* skip VFS prefix */
 397         if (url_params != NULL)
 398         {
 399             *url_params = '\0';
 400             url_params++;
 401             vfs_path_url_split (element, url_params);
 402         }
 403
 404         if (*op != '\0')
 405             element->vfs_prefix = g_strdup (op);
 406
 407         g_array_prepend_val (vpath->path, element);
 408     }
 409     if (path[0] != '\0')
 410     {
 411         element = g_new0 (vfs_path_element_t, 1);
 412         element->class = g_ptr_array_index (vfs__classes_list, 0);
 413         element->path = vfs_translate_path_n (path);
 414
 415 #ifdef HAVE_CHARSET
 416         element->encoding = vfs_get_encoding (path);
 417         element->dir.converter =
 418             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 419 #endif
 420         g_array_prepend_val (vpath->path, element);
 421     }
 422
 423     return vpath;
 424 }
 425
 426 /* --------------------------------------------------------------------------------------------- */
 427 /** Split path string to path elements by URL algorithm.
 428  *
 429  * @param path_str VFS-path
 430  * @param flags    flags for converter
 431  *
 432  * @return pointer to newly created vfs_path_t object with filled path elements array.
 433 */
 434
 435 static vfs_path_t *
 436 vfs_path_from_str_uri_parser (char *path, vfs_path_flag_t flags)
 437 {
 438     vfs_path_t *vpath;
 439     vfs_path_element_t *element;
 440
 441     char *url_delimiter;
 442
 443     vpath = vfs_path_new ();
 444     vpath->relative = (flags & VPF_NO_CANON) != 0;
 445
 446     while ((url_delimiter = g_strrstr (path, VFS_PATH_URL_DELIMITER)) != NULL)
 447     {
 448         char *vfs_prefix_start;
 449         char *real_vfs_prefix_start = url_delimiter;
 450         char *slash_pointer;
 451         struct vfs_s_subclass *sub = NULL;
 452
 453         while (real_vfs_prefix_start > path && *(real_vfs_prefix_start) != PATH_SEP)
 454             real_vfs_prefix_start--;
 455         vfs_prefix_start = real_vfs_prefix_start;
 456
 457         if (*(vfs_prefix_start) == PATH_SEP)
 458             vfs_prefix_start += 1;
 459
 460         *url_delimiter = '\0';
 461
 462         element = g_new0 (vfs_path_element_t, 1);
 463         element->class = vfs_prefix_to_class (vfs_prefix_start);
 464         element->vfs_prefix = g_strdup (vfs_prefix_start);
 465
 466         url_delimiter += strlen (VFS_PATH_URL_DELIMITER);
 467         sub = VFSDATA (element);
 468         if (sub != NULL && (sub->flags & VFS_S_REMOTE) != 0)
 469         {
 470             slash_pointer = strchr (url_delimiter, PATH_SEP);
 471             if (slash_pointer == NULL)
 472             {
 473                 element->path = g_strdup ("");
 474             }
 475             else
 476             {
 477                 element->path = vfs_translate_path_n (slash_pointer + 1);
 478 #ifdef HAVE_CHARSET
 479                 element->encoding = vfs_get_encoding (slash_pointer);
 480 #endif
 481                 *slash_pointer = '\0';
 482             }
 483             vfs_path_url_split (element, url_delimiter);
 484         }
 485         else
 486         {
 487             element->path = vfs_translate_path_n (url_delimiter);
 488 #ifdef HAVE_CHARSET
 489             element->encoding = vfs_get_encoding (url_delimiter);
 490 #endif
 491         }
 492 #ifdef HAVE_CHARSET
 493         element->dir.converter =
 494             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 495 #endif
 496         g_array_prepend_val (vpath->path, element);
 497
 498         if ((real_vfs_prefix_start > path && *(real_vfs_prefix_start) == PATH_SEP) ||
 499             (real_vfs_prefix_start == path && *(real_vfs_prefix_start) != PATH_SEP))
 500             *real_vfs_prefix_start = '\0';
 501         else
 502             *(real_vfs_prefix_start + 1) = '\0';
 503     }
 504
 505     if (path[0] != '\0')
 506     {
 507         element = g_new0 (vfs_path_element_t, 1);
 508         element->class = g_ptr_array_index (vfs__classes_list, 0);
 509         element->path = vfs_translate_path_n (path);
 510 #ifdef HAVE_CHARSET
 511         element->encoding = vfs_get_encoding (path);
 512         element->dir.converter =
 513             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
 514 #endif
 515         g_array_prepend_val (vpath->path, element);
 516     }
 517
 518     return vpath;
 519 }
 520
 521 /* --------------------------------------------------------------------------------------------- */
 522 /**
 523  * Add element's class info to result string (such as VFS name, host, encoding etc)
 524  * This function used as helper only in vfs_path_tokens_get() function
 525  *
 526  * @param element current path element
 527  * @param ret_tokens total tikens for return
 528  * @param element_tokens accumulated element-only tokens
 529  */
 530
 531 static void
 532 vfs_path_tokens_add_class_info (const vfs_path_element_t * element, GString * ret_tokens,
 533                                 GString * element_tokens)
 534 {
 535     if (((element->class->flags & VFSF_LOCAL) == 0 || ret_tokens->len > 0)
 536         && element_tokens->len > 0)
 537     {
 538         char *url_str;
 539
 540         if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP)
 541             g_string_append_c (ret_tokens, PATH_SEP);
 542
 543         g_string_append (ret_tokens, element->vfs_prefix);
 544         g_string_append (ret_tokens, VFS_PATH_URL_DELIMITER);
 545
 546         url_str = vfs_path_build_url_params_str (element, TRUE);
 547         if (*url_str != '\0')
 548         {
 549             g_string_append (ret_tokens, url_str);
 550             g_string_append_c (ret_tokens, PATH_SEP);
 551         }
 552
 553         g_free (url_str);
 554     }
 555
 556 #ifdef HAVE_CHARSET
 557     if (element->encoding != NULL)
 558     {
 559         if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP)
 560             g_string_append (ret_tokens, PATH_SEP_STR);
 561         g_string_append (ret_tokens, VFS_ENCODING_PREFIX);
 562         g_string_append (ret_tokens, element->encoding);
 563         g_string_append (ret_tokens, PATH_SEP_STR);
 564     }
 565 #endif
 566
 567     g_string_append (ret_tokens, element_tokens->str);
 568 }
 569
 570 /* --------------------------------------------------------------------------------------------- */
 571 /**
 572  * Strip path to home dir.
 573  * @param dir pointer to string contains full path
 574  */
 575
 576 static char *
 577 vfs_path_strip_home (const char *dir)
 578 {
 579     const char *home_dir = mc_config_get_home_dir ();
 580
 581     if (home_dir != NULL)
 582     {
 583         size_t len;
 584
 585         len = strlen (home_dir);
 586
 587         if (strncmp (dir, home_dir, len) == 0 && (dir[len] == PATH_SEP || dir[len] == '\0'))
 588             return g_strdup_printf ("~%s", dir + len);
 589     }
 590
 591     return g_strdup (dir);
 592 }
 593
 594 /* --------------------------------------------------------------------------------------------- */
 595
 596 /* --------------------------------------------------------------------------------------------- */
 597 /*** public functions ****************************************************************************/
 598 /* --------------------------------------------------------------------------------------------- */
 599
 600 #define vfs_append_from_path(appendfrom, is_relative) \
 601 { \
 602     if ((flags & VPF_STRIP_HOME) && element_index == 0 && (element->class->flags & VFSF_LOCAL) != 0) \
 603     { \
 604         char *stripped_home_str; \
 605         stripped_home_str = vfs_path_strip_home (appendfrom); \
 606         g_string_append (buffer, stripped_home_str); \
 607         g_free (stripped_home_str); \
 608     } \
 609     else \
 610     { \
 611         if ((!is_relative) && (*appendfrom != PATH_SEP) && (*appendfrom != '\0') \
 612             && (buffer->len == 0 || buffer->str[buffer->len - 1] != PATH_SEP)) \
 613             g_string_append_c (buffer, PATH_SEP); \
 614         g_string_append (buffer, appendfrom); \
 615     } \
 616 }
 617
 618 /**
 619  * Convert first elements_count elements from vfs_path_t to string representation with flags.
 620  *
 621  * @param vpath pointer to vfs_path_t object
 622  * @param elements_count count of first elements for convert
 623  * @param flags for converter
 624  *
 625  * @return pointer to newly created string.
 626  */
 627
 628 char *
 629 vfs_path_to_str_flags (const vfs_path_t * vpath, int elements_count, vfs_path_flag_t flags)
 630 {
 631     int element_index;
 632     GString *buffer;
 633     GString *recode_buffer;
 634
 635     if (vpath == NULL)
 636         return NULL;
 637
 638     if (elements_count == 0 || elements_count > vfs_path_elements_count (vpath))
 639         elements_count = vfs_path_elements_count (vpath);
 640
 641     if (elements_count < 0)
 642         elements_count = vfs_path_elements_count (vpath) + elements_count;
 643
 644     buffer = g_string_new ("");
 645     recode_buffer = g_string_new ("");
 646
 647     for (element_index = 0; element_index < elements_count; element_index++)
 648     {
 649         const vfs_path_element_t *element;
 650         gboolean is_relative = vpath->relative && (element_index == 0);
 651
 652         element = vfs_path_get_by_index (vpath, element_index);
 653         if (element->vfs_prefix != NULL)
 654         {
 655             char *url_str;
 656             if ((!is_relative) && (buffer->len == 0 || buffer->str[buffer->len - 1] != PATH_SEP))
 657                 g_string_append_c (buffer, PATH_SEP);
 658
 659             g_string_append (buffer, element->vfs_prefix);
 660             g_string_append (buffer, VFS_PATH_URL_DELIMITER);
 661
 662             url_str = vfs_path_build_url_params_str (element, !(flags & VPF_STRIP_PASSWORD));
 663
 664             if (*url_str != '\0')
 665             {
 666                 g_string_append (buffer, url_str);
 667                 g_string_append_c (buffer, PATH_SEP);
 668             }
 669
 670             g_free (url_str);
 671         }
 672
 673 #ifdef HAVE_CHARSET
 674         if ((flags & VPF_RECODE) == 0 && vfs_path_element_need_cleanup_converter (element))
 675         {
 676             if ((flags & VPF_HIDE_CHARSET) == 0)
 677             {
 678                 if ((!is_relative)
 679                     && (buffer->len == 0 || buffer->str[buffer->len - 1] != PATH_SEP))
 680                     g_string_append (buffer, PATH_SEP_STR);
 681                 g_string_append (buffer, VFS_ENCODING_PREFIX);
 682                 g_string_append (buffer, element->encoding);
 683             }
 684             str_vfs_convert_from (element->dir.converter, element->path, recode_buffer);
 685             vfs_append_from_path (recode_buffer->str, is_relative);
 686             g_string_set_size (recode_buffer, 0);
 687         }
 688         else
 689 #endif
 690         {
 691             vfs_append_from_path (element->path, is_relative);
 692         }
 693     }
 694     g_string_free (recode_buffer, TRUE);
 695     return g_string_free (buffer, FALSE);
 696 }
 697
 698 #undef vfs_append_from_path
 699
 700 /* --------------------------------------------------------------------------------------------- */
 701 /**
 702  * Convert first elements_count elements from vfs_path_t to string representation.
 703  *
 704  * @param vpath pointer to vfs_path_t object
 705  * @param elements_count count of first elements for convert
 706  *
 707  * @return pointer to newly created string.
 708  */
 709
 710 char *
 711 vfs_path_to_str_elements_count (const vfs_path_t * vpath, int elements_count)
 712 {
 713     return vfs_path_to_str_flags (vpath, elements_count, VPF_NONE);
 714 }
 715
 716 /* --------------------------------------------------------------------------------------------- */
 717 /**
 718  * Convert vfs_path_t to string representation.
 719  *
 720  * @param vpath pointer to vfs_path_t object
 721  *
 722  * @return pointer to newly created string.
 723  */
 724
 725 char *
 726 vfs_path_to_str (const vfs_path_t * vpath)
 727 {
 728     return vfs_path_to_str_elements_count (vpath, vfs_path_elements_count (vpath));
 729 }
 730
 731 /* --------------------------------------------------------------------------------------------- */
 732 /**
 733  * Split path string to path elements with flags for change parce process.
 734  *
 735  * @param path_str VFS-path
 736  * @param flags flags for parser
 737  *
 738  * @return pointer to newly created vfs_path_t object with filled path elements array.
 739  */
 740
 741 vfs_path_t *
 742 vfs_path_from_str_flags (const char *path_str, vfs_path_flag_t flags)
 743 {
 744     vfs_path_t *vpath;
 745     char *path;
 746
 747     if (path_str == NULL)
 748         return NULL;
 749
 750     if ((flags & VPF_NO_CANON) == 0)
 751         path = vfs_canon (path_str);
 752     else
 753         path = g_strdup (path_str);
 754
 755     if (path == NULL)
 756         return NULL;
 757
 758     if ((flags & VPF_USE_DEPRECATED_PARSER) != 0 && vfs_path_is_str_path_deprecated (path))
 759         vpath = vfs_path_from_str_deprecated_parser (path, flags);
 760     else
 761         vpath = vfs_path_from_str_uri_parser (path, flags);
 762
 763     g_free (path);
 764
 765     return vpath;
 766 }
 767
 768 /* --------------------------------------------------------------------------------------------- */
 769 /**
 770  * Split path string to path elements.
 771  *
 772  * @param path_str VFS-path
 773  *
 774  * @return pointer to newly created vfs_path_t object with filled path elements array.
 775  */
 776
 777 vfs_path_t *
 778 vfs_path_from_str (const char *path_str)
 779 {
 780     return vfs_path_from_str_flags (path_str, VPF_NONE);
 781 }
 782
 783 /* --------------------------------------------------------------------------------------------- */
 784 /*
 785  * Create new vfs_path_t object.
 786  *
 787  * @return pointer to newly created vfs_path_t object.
 788  */
 789
 790 vfs_path_t *
 791 vfs_path_new (void)
 792 {
 793     vfs_path_t *vpath;
 794
 795     vpath = g_new0 (vfs_path_t, 1);
 796     vpath->path = g_array_new (FALSE, TRUE, sizeof (vfs_path_element_t *));
 797
 798     return vpath;
 799 }
 800
 801 /* --------------------------------------------------------------------------------------------- */
 802 /*
 803  * Get count of path elements.
 804  *
 805  * @param vpath pointer to vfs_path_t object
 806  *
 807  * @return count of path elements.
 808  */
 809
 810 int
 811 vfs_path_elements_count (const vfs_path_t * vpath)
 812 {
 813     return (vpath != NULL && vpath->path != NULL) ? vpath->path->len : 0;
 814 }
 815
 816 /* --------------------------------------------------------------------------------------------- */
 817 /**
 818  * Add vfs_path_element_t object to end of list in vfs_path_t object
 819  * @param vpath pointer to vfs_path_t object
 820  * @param path_element pointer to vfs_path_element_t object
 821  */
 822
 823 void
 824 vfs_path_add_element (const vfs_path_t * vpath, const vfs_path_element_t * path_element)
 825 {
 826     g_array_append_val (vpath->path, path_element);
 827 }
 828
 829 /* --------------------------------------------------------------------------------------------- */
 830 /*
 831  * Get one path element by index.
 832  *
 833  * @param vpath pointer to vfs_path_t object
 834  * @param element_index element index. May have negative value (in this case count was started at the end of list).
 835  *
 836  * @return path element.
 837  */
 838
 839 const vfs_path_element_t *
 840 vfs_path_get_by_index (const vfs_path_t * vpath, int element_index)
 841 {
 842     if (vpath == NULL)
 843         return NULL;
 844
 845     if (element_index < 0)
 846         element_index += vfs_path_elements_count (vpath);
 847
 848     if (element_index < 0)
 849         vfs_die ("vfs_path_get_by_index: incorrect index!");
 850
 851     return g_array_index (vpath->path, vfs_path_element_t *, element_index);
 852 }
 853
 854 /* --------------------------------------------------------------------------------------------- */
 855 /*
 856  * Clone one path element
 857  *
 858  * @param element pointer to vfs_path_element_t object
 859  *
 860  * @return Newly allocated path element
 861  */
 862
 863 vfs_path_element_t *
 864 vfs_path_element_clone (const vfs_path_element_t * element)
 865 {
 866     vfs_path_element_t *new_element = g_new (vfs_path_element_t, 1);
 867
 868     new_element->user = g_strdup (element->user);
 869     new_element->password = g_strdup (element->password);
 870     new_element->host = g_strdup (element->host);
 871     new_element->ipv6 = element->ipv6;
 872     new_element->port = element->port;
 873     new_element->path = g_strdup (element->path);
 874     new_element->class = element->class;
 875     new_element->vfs_prefix = g_strdup (element->vfs_prefix);
 876 #ifdef HAVE_CHARSET
 877     new_element->encoding = g_strdup (element->encoding);
 878     if (vfs_path_element_need_cleanup_converter (element) && new_element->encoding != NULL)
 879         new_element->dir.converter = str_crt_conv_from (new_element->encoding);
 880     else
 881         new_element->dir.converter = element->dir.converter;
 882 #endif
 883     new_element->dir.info = element->dir.info;
 884
 885     return new_element;
 886 }
 887
 888 /* --------------------------------------------------------------------------------------------- */
 889 /*
 890  * Free one path element.
 891  *
 892  * @param element pointer to vfs_path_element_t object
 893  *
 894  */
 895
 896 void
 897 vfs_path_element_free (vfs_path_element_t * element)
 898 {
 899     if (element == NULL)
 900         return;
 901
 902     g_free (element->user);
 903     g_free (element->password);
 904     g_free (element->host);
 905     g_free (element->path);
 906     g_free (element->vfs_prefix);
 907
 908 #ifdef HAVE_CHARSET
 909     g_free (element->encoding);
 910
 911     if (vfs_path_element_need_cleanup_converter (element))
 912         str_close_conv (element->dir.converter);
 913 #endif
 914
 915     g_free (element);
 916 }
 917
 918 /* --------------------------------------------------------------------------------------------- */
 919 /*
 920  * Clone path
 921  *
 922  * @param vpath pointer to vfs_path_t object
 923  *
 924  * @return Newly allocated path object
 925  */
 926
 927 vfs_path_t *
 928 vfs_path_clone (const vfs_path_t * vpath)
 929 {
 930     vfs_path_t *new_vpath;
 931     int vpath_element_index;
 932
 933     if (vpath == NULL)
 934         return NULL;
 935
 936     new_vpath = vfs_path_new ();
 937     new_vpath->relative = vpath->relative;
 938
 939     for (vpath_element_index = 0; vpath_element_index < vfs_path_elements_count (vpath);
 940          vpath_element_index++)
 941     {
 942         vfs_path_element_t *path_element;
 943
 944         path_element = vfs_path_element_clone (vfs_path_get_by_index (vpath, vpath_element_index));
 945         g_array_append_val (new_vpath->path, path_element);
 946     }
 947
 948     return new_vpath;
 949 }
 950
 951 /* --------------------------------------------------------------------------------------------- */
 952 /*
 953  * Free vfs_path_t object.
 954  *
 955  * @param vpath pointer to vfs_path_t object
 956  *
 957  */
 958
 959 void
 960 vfs_path_free (vfs_path_t * vpath)
 961 {
 962     int vpath_element_index;
 963
 964     if (vpath == NULL)
 965         return;
 966
 967     for (vpath_element_index = 0; vpath_element_index < vfs_path_elements_count (vpath);
 968          vpath_element_index++)
 969     {
 970         vfs_path_element_t *path_element;
 971
 972         path_element = (vfs_path_element_t *) vfs_path_get_by_index (vpath, vpath_element_index);
 973         vfs_path_element_free (path_element);
 974     }
 975
 976     g_array_free (vpath->path, TRUE);
 977     g_free (vpath);
 978 }
 979
 980 /* --------------------------------------------------------------------------------------------- */
 981 /*
 982  * Remove one path element by index
 983  *
 984  * @param vpath pointer to vfs_path_t object
 985  * @param element_index element index. May have negative value (in this case count was started at the end of list).
 986  *
 987  */
 988
 989 void
 990 vfs_path_remove_element_by_index (vfs_path_t * vpath, int element_index)
 991 {
 992     vfs_path_element_t *element;
 993
 994     if ((vpath == NULL) || (vfs_path_elements_count (vpath) == 1))
 995         return;
 996
 997     if (element_index < 0)
 998         element_index = vfs_path_elements_count (vpath) + element_index;
 999
1000     element = (vfs_path_element_t *) vfs_path_get_by_index (vpath, element_index);
1001     vpath->path = g_array_remove_index (vpath->path, element_index);
1002     vfs_path_element_free (element);
1003 }
1004
1005 /* --------------------------------------------------------------------------------------------- */
1006 /** Return VFS class for the given prefix */
1007
1008 struct vfs_class *
1009 vfs_prefix_to_class (const char *prefix)
1010 {
1011     guint i;
1012
1013     /* Avoid first class (localfs) that would accept any prefix */
1014     for (i = 1; i < vfs__classes_list->len; i++)
1015     {
1016         struct vfs_class *vfs;
1017
1018         vfs = (struct vfs_class *) g_ptr_array_index (vfs__classes_list, i);
1019         if (vfs->which != NULL)
1020         {
1021             if (vfs->which (vfs, prefix) == -1)
1022                 continue;
1023             return vfs;
1024         }
1025
1026         if (vfs->prefix != NULL && strncmp (prefix, vfs->prefix, strlen (vfs->prefix)) == 0)
1027             return vfs;
1028     }
1029
1030     return NULL;
1031 }
1032
1033 /* --------------------------------------------------------------------------------------------- */
1034
1035 #ifdef HAVE_CHARSET
1036
1037 /**
1038  * Check if need cleanup charset converter for vfs_path_element_t
1039  *
1040  * @param element part of path
1041  *
1042  * @return TRUE if need cleanup converter or FALSE otherwise
1043  */
1044
1045 gboolean
1046 vfs_path_element_need_cleanup_converter (const vfs_path_element_t * element)
1047 {
1048     return (element->dir.converter != str_cnv_from_term && element->dir.converter != INVALID_CONV);
1049 }
1050 #endif
1051
1052 /* --------------------------------------------------------------------------------------------- */
1053
1054 /**
1055  * Serialize vfs_path_t object to string
1056  *
1057  * @param vpath data for serialization
1058  * @param error contain pointer to object for handle error code and message
1059  *
1060  * @return serialized vpath as newly allocated string
1061  */
1062
1063 char *
1064 vfs_path_serialize (const vfs_path_t * vpath, GError ** error)
1065 {
1066     mc_config_t *cpath;
1067     ssize_t element_index;
1068     char *ret_value;
1069
1070     if ((vpath == NULL) || (vfs_path_elements_count (vpath) == 0))
1071     {
1072         g_set_error (error, MC_ERROR, -1, "vpath object is empty");
1073         return NULL;
1074
1075     }
1076
1077     cpath = mc_config_init (NULL, FALSE);
1078
1079     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
1080     {
1081         char *groupname;
1082         const vfs_path_element_t *element;
1083
1084         groupname = g_strdup_printf ("path-element-%zd", element_index);
1085         element = vfs_path_get_by_index (vpath, element_index);
1086         /* convert one element to config group */
1087
1088         mc_config_set_string_raw (cpath, groupname, "path", element->path);
1089         mc_config_set_string_raw (cpath, groupname, "class-name", element->class->name);
1090 #ifdef HAVE_CHARSET
1091         mc_config_set_string_raw (cpath, groupname, "encoding", element->encoding);
1092 #endif
1093         mc_config_set_string_raw (cpath, groupname, "vfs_prefix", element->vfs_prefix);
1094
1095         mc_config_set_string_raw (cpath, groupname, "user", element->user);
1096         mc_config_set_string_raw (cpath, groupname, "password", element->password);
1097         mc_config_set_string_raw (cpath, groupname, "host", element->host);
1098         if (element->port != 0)
1099             mc_config_set_int (cpath, groupname, "port", element->port);
1100
1101         g_free (groupname);
1102     }
1103
1104     ret_value = mc_serialize_config (cpath, error);
1105     mc_config_deinit (cpath);
1106     return ret_value;
1107 }
1108
1109 /* --------------------------------------------------------------------------------------------- */
1110 /**
1111  * Deserialize string to vfs_path_t object
1112  *
1113  * @param data data for serialization
1114  * @param error contain pointer to object for handle error code and message
1115  *
1116  * @return newly allocated vfs_path_t object
1117  */
1118
1119 vfs_path_t *
1120 vfs_path_deserialize (const char *data, GError ** error)
1121 {
1122     mc_config_t *cpath;
1123     size_t element_index = 0;
1124     vfs_path_t *vpath;
1125
1126     cpath = mc_deserialize_config (data, error);
1127     if (cpath == NULL)
1128         return NULL;
1129
1130     vpath = vfs_path_new ();
1131
1132     while (TRUE)
1133     {
1134         vfs_path_element_t *element;
1135         char *cfg_value;
1136         char *groupname;
1137
1138         groupname = g_strdup_printf ("path-element-%zd", element_index);
1139         if (!mc_config_has_group (cpath, groupname))
1140         {
1141             g_free (groupname);
1142             break;
1143         }
1144
1145         element = g_new0 (vfs_path_element_t, 1);
1146
1147         cfg_value = mc_config_get_string_raw (cpath, groupname, "class-name", NULL);
1148         element->class = vfs_get_class_by_name (cfg_value);
1149         if (element->class == NULL)
1150         {
1151             g_free (element);
1152             vfs_path_free (vpath);
1153             g_set_error (error, MC_ERROR, -1, "Unable to find VFS class by name '%s'", cfg_value);
1154             g_free (cfg_value);
1155             mc_config_deinit (cpath);
1156             return NULL;
1157         }
1158         g_free (cfg_value);
1159
1160         element->path = mc_config_get_string_raw (cpath, groupname, "path", NULL);
1161
1162 #ifdef HAVE_CHARSET
1163         element->encoding = mc_config_get_string_raw (cpath, groupname, "encoding", NULL);
1164         element->dir.converter =
1165             (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV;
1166 #endif
1167
1168         element->vfs_prefix = mc_config_get_string_raw (cpath, groupname, "vfs_prefix", NULL);
1169
1170         element->user = mc_config_get_string_raw (cpath, groupname, "user", NULL);
1171         element->password = mc_config_get_string_raw (cpath, groupname, "password", NULL);
1172         element->host = mc_config_get_string_raw (cpath, groupname, "host", NULL);
1173         element->port = mc_config_get_int (cpath, groupname, "port", 0);
1174
1175         vpath->path = g_array_append_val (vpath->path, element);
1176
1177         g_free (groupname);
1178         element_index++;
1179     }
1180
1181     mc_config_deinit (cpath);
1182     if (vfs_path_elements_count (vpath) == 0)
1183     {
1184         vfs_path_free (vpath);
1185         g_set_error (error, MC_ERROR, -1, "No any path elements found");
1186         return NULL;
1187     }
1188
1189     return vpath;
1190 }
1191
1192 /* --------------------------------------------------------------------------------------------- */
1193 /**
1194  * Build vfs_path_t object from arguments.
1195  *
1196  * @param first_element of path
1197  * @param ... path tokens, terminated by NULL
1198  *
1199  * @return newly allocated vfs_path_t object
1200  */
1201
1202 vfs_path_t *
1203 vfs_path_build_filename (const char *first_element, ...)
1204 {
1205     va_list args;
1206     char *str_path;
1207     vfs_path_t *vpath;
1208
1209     if (first_element == NULL)
1210         return NULL;
1211
1212     va_start (args, first_element);
1213     str_path = mc_build_filenamev (first_element, args);
1214     va_end (args);
1215     vpath = vfs_path_from_str (str_path);
1216     g_free (str_path);
1217     return vpath;
1218 }
1219
1220 /* --------------------------------------------------------------------------------------------- */
1221 /**
1222  * Append tokens to path object
1223  *
1224  * @param vpath path object
1225  * @param first_element of path
1226  * @param ... NULL-terminated strings
1227  *
1228  * @return newly allocated path object
1229  */
1230
1231 vfs_path_t *
1232 vfs_path_append_new (const vfs_path_t * vpath, const char *first_element, ...)
1233 {
1234     va_list args;
1235     char *str_path, *result_str;
1236     vfs_path_t *ret_vpath;
1237
1238     if (vpath == NULL || first_element == NULL)
1239         return NULL;
1240
1241     va_start (args, first_element);
1242     str_path = mc_build_filenamev (first_element, args);
1243     va_end (args);
1244
1245     result_str = vfs_path_to_str (vpath);
1246     ret_vpath = vfs_path_build_filename (result_str, str_path, NULL);
1247     g_free (result_str);
1248     g_free (str_path);
1249
1250     return ret_vpath;
1251
1252 }
1253
1254 /* --------------------------------------------------------------------------------------------- */
1255
1256 /**
1257  * Append vpath_t tokens to path object
1258  *
1259  * @param first_vpath vpath objects
1260  * @param ... NULL-terminated vpath objects
1261  *
1262  * @return newly allocated path object
1263  */
1264
1265 vfs_path_t *
1266 vfs_path_append_vpath_new (const vfs_path_t * first_vpath, ...)
1267 {
1268     va_list args;
1269     vfs_path_t *ret_vpath;
1270     const vfs_path_t *current_vpath = first_vpath;
1271
1272     if (first_vpath == NULL)
1273         return NULL;
1274
1275     ret_vpath = vfs_path_new ();
1276
1277     va_start (args, first_vpath);
1278     do
1279     {
1280         int vindex;
1281
1282         for (vindex = 0; vindex < vfs_path_elements_count (current_vpath); vindex++)
1283         {
1284             vfs_path_element_t *path_element;
1285
1286             path_element = vfs_path_element_clone (vfs_path_get_by_index (current_vpath, vindex));
1287             g_array_append_val (ret_vpath->path, path_element);
1288         }
1289         current_vpath = va_arg (args, const vfs_path_t *);
1290     }
1291     while (current_vpath != NULL);
1292     va_end (args);
1293
1294     return ret_vpath;
1295 }
1296
1297 /* --------------------------------------------------------------------------------------------- */
1298
1299 /**
1300  * get tockens count in path.
1301  *
1302  * @param vpath path object
1303  *
1304  * @return count of tokens
1305  */
1306
1307 size_t
1308 vfs_path_tokens_count (const vfs_path_t * vpath)
1309 {
1310     size_t count_tokens = 0;
1311     int element_index;
1312
1313     if (vpath == NULL)
1314         return 0;
1315
1316     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
1317     {
1318         const vfs_path_element_t *element;
1319         char **path_tokens, **iterator;
1320
1321         element = vfs_path_get_by_index (vpath, element_index);
1322         path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1);
1323
1324         while (*iterator != NULL)
1325         {
1326             if (**iterator != '\0')
1327                 count_tokens++;
1328             iterator++;
1329         }
1330         g_strfreev (path_tokens);
1331     }
1332     return count_tokens;
1333 }
1334
1335 /* --------------------------------------------------------------------------------------------- */
1336
1337 /**
1338  * Get subpath by tokens
1339  *
1340  * @param vpath path object
1341  * @param start_position first token for got/ Started from 0.
1342  *        If negative, then position will be relative to end of path
1343  * @param length count of tokens
1344  *
1345  * @return newly allocated string with path tokens separated by slash
1346  */
1347
1348 char *
1349 vfs_path_tokens_get (const vfs_path_t * vpath, ssize_t start_position, ssize_t length)
1350 {
1351     GString *ret_tokens, *element_tokens;
1352     int element_index;
1353     size_t tokens_count = vfs_path_tokens_count (vpath);
1354
1355     if (vpath == NULL)
1356         return NULL;
1357
1358     if (length == 0)
1359         length = tokens_count;
1360
1361     if (length < 0)
1362         length = tokens_count + length;
1363
1364     if (start_position < 0)
1365         start_position = (ssize_t) tokens_count + start_position;
1366
1367     if (start_position < 0)
1368         return NULL;
1369
1370     if (start_position >= (ssize_t) tokens_count)
1371         return NULL;
1372
1373     if (start_position + (ssize_t) length > (ssize_t) tokens_count)
1374         length = tokens_count - start_position;
1375
1376     ret_tokens = g_string_sized_new (32);
1377     element_tokens = g_string_sized_new (32);
1378
1379     for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++)
1380     {
1381         const vfs_path_element_t *element;
1382         char **path_tokens, **iterator;
1383
1384         g_string_assign (element_tokens, "");
1385         element = vfs_path_get_by_index (vpath, element_index);
1386         path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1);
1387
1388         while (*iterator != NULL)
1389         {
1390             if (**iterator != '\0')
1391             {
1392                 if (start_position == 0)
1393                 {
1394                     if (length == 0)
1395                     {
1396                         vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens);
1397                         g_string_free (element_tokens, TRUE);
1398                         g_strfreev (path_tokens);
1399                         return g_string_free (ret_tokens, FALSE);
1400                     }
1401                     length--;
1402                     if (element_tokens->len != 0)
1403                         g_string_append_c (element_tokens, PATH_SEP);
1404                     g_string_append (element_tokens, *iterator);
1405                 }
1406                 else
1407                     start_position--;
1408             }
1409             iterator++;
1410         }
1411         g_strfreev (path_tokens);
1412         vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens);
1413     }
1414
1415     g_string_free (element_tokens, TRUE);
1416     return g_string_free (ret_tokens, !(start_position == 0 && length == 0));
1417 }
1418
1419 /* --------------------------------------------------------------------------------------------- */
1420 /**
1421  * Get subpath by tokens
1422  *
1423  * @param vpath path object
1424  * @param start_position first token for got/ Started from 0.
1425  *        If negative, then position will be relative to end of path
1426  * @param length count of tokens
1427  *
1428  * @return newly allocated path object with path tokens separated by slash
1429  */
1430
1431 vfs_path_t *
1432 vfs_path_vtokens_get (const vfs_path_t * vpath, ssize_t start_position, ssize_t length)
1433 {
1434     char *str_tokens;
1435     vfs_path_t *ret_vpath = NULL;
1436
1437     str_tokens = vfs_path_tokens_get (vpath, start_position, length);
1438     if (str_tokens != NULL)
1439     {
1440         ret_vpath = vfs_path_from_str_flags (str_tokens, VPF_NO_CANON);
1441         g_free (str_tokens);
1442     }
1443     return ret_vpath;
1444 }
1445
1446 /* --------------------------------------------------------------------------------------------- */
1447
1448 /**
1449  * Build URL parameters (such as user:pass @ host:port) from one path element object
1450  *
1451  * @param element path element
1452  * @param keep_password TRUE or FALSE
1453  *
1454  * @return newly allocated string
1455  */
1456
1457 char *
1458 vfs_path_build_url_params_str (const vfs_path_element_t * element, gboolean keep_password)
1459 {
1460     GString *buffer;
1461
1462     if (element == NULL)
1463         return NULL;
1464
1465     buffer = g_string_new ("");
1466
1467     if (element->user != NULL)
1468         g_string_append (buffer, element->user);
1469
1470     if (element->password != NULL && keep_password)
1471     {
1472         g_string_append_c (buffer, ':');
1473         g_string_append (buffer, element->password);
1474     }
1475
1476     if (element->host != NULL)
1477     {
1478         if ((element->user != NULL) || (element->password != NULL))
1479             g_string_append_c (buffer, '@');
1480         if (element->ipv6)
1481             g_string_append_c (buffer, '[');
1482         g_string_append (buffer, element->host);
1483         if (element->ipv6)
1484             g_string_append_c (buffer, ']');
1485     }
1486
1487     if ((element->port) != 0 && (element->host != NULL))
1488     {
1489         g_string_append_c (buffer, ':');
1490         g_string_append_printf (buffer, "%d", element->port);
1491     }
1492
1493     return g_string_free (buffer, FALSE);
1494 }
1495
1496 /* --------------------------------------------------------------------------------------------- */
1497 /**
1498  * Build pretty string representation of one path_element_t object
1499  *
1500  * @param element path element
1501  *
1502  * @return newly allocated string
1503  */
1504
1505 char *
1506 vfs_path_element_build_pretty_path_str (const vfs_path_element_t * element)
1507 {
1508     char *url_params;
1509     GString *pretty_path;
1510
1511     pretty_path = g_string_new (element->class->prefix);
1512     g_string_append (pretty_path, VFS_PATH_URL_DELIMITER);
1513
1514     url_params = vfs_path_build_url_params_str (element, FALSE);
1515     g_string_append (pretty_path, url_params);
1516     g_free (url_params);
1517
1518     if (*element->path != PATH_SEP)
1519         g_string_append_c (pretty_path, PATH_SEP);
1520
1521     g_string_append (pretty_path, element->path);
1522     return g_string_free (pretty_path, FALSE);
1523 }
1524
1525 /* --------------------------------------------------------------------------------------------- */
1526 /**
1527  * Compare two path objects as strings
1528  *
1529  * @param vpath1 first path object
1530  * @param vpath2 second vpath object
1531  *
1532  * @return integer value like to strcmp.
1533  */
1534
1535 int
1536 vfs_path_cmp (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1537 {
1538     char *path1;
1539     char *path2;
1540     int ret_val;
1541
1542     if (vpath1 == NULL || vpath2 == NULL)
1543         return -1;
1544
1545     path1 = vfs_path_to_str (vpath1);
1546     path2 = vfs_path_to_str (vpath2);
1547
1548     ret_val = strcmp (path1, path2);
1549
1550     g_free (path1);
1551     g_free (path2);
1552
1553     return ret_val;
1554 }
1555
1556 /* --------------------------------------------------------------------------------------------- */
1557 /**
1558  * Compare two path objects as strings
1559  *
1560  * @param vpath1 first path object
1561  * @param vpath2 second vpath object
1562  * @param len number of first 'len' characters
1563  *
1564  * @return integer value like to strcmp.
1565  */
1566
1567 int
1568 vfs_path_ncmp (const vfs_path_t * vpath1, const vfs_path_t * vpath2, size_t len)
1569 {
1570     char *path1;
1571     char *path2;
1572     int ret_val;
1573
1574     if (vpath1 == NULL || vpath2 == NULL)
1575         return -1;
1576
1577     path1 = vfs_path_to_str (vpath1);
1578     path2 = vfs_path_to_str (vpath2);
1579
1580     ret_val = strncmp (path1, path2, len);
1581
1582     g_free (path1);
1583     g_free (path2);
1584
1585     return ret_val;
1586 }
1587
1588 /* --------------------------------------------------------------------------------------------- */
1589 /**
1590  * Calculate path length in string representation
1591  *
1592  * @param vpath path object
1593  *
1594  * @return length of path
1595  */
1596
1597 size_t
1598 vfs_path_len (const vfs_path_t * vpath)
1599 {
1600     char *path;
1601     size_t ret_val;
1602
1603     if (vpath == NULL)
1604         return 0;
1605
1606     path = vfs_path_to_str (vpath);
1607     ret_val = strlen (path);
1608     g_free (path);
1609     return ret_val;
1610 }
1611
1612 /* --------------------------------------------------------------------------------------------- */
1613 /**
1614  * Convert relative vpath object to absolute
1615  *
1616  * @param vpath path object
1617  *
1618  * @return absolute path object
1619  */
1620
1621 vfs_path_t *
1622 vfs_path_to_absolute (const vfs_path_t * vpath)
1623 {
1624     vfs_path_t *absolute_vpath;
1625     char *path_str;
1626
1627     if (!vpath->relative)
1628         return vfs_path_clone (vpath);
1629
1630     path_str = vfs_path_to_str (vpath);
1631     absolute_vpath = vfs_path_from_str (path_str);
1632     g_free (path_str);
1633     return absolute_vpath;
1634 }
1635
1636 /* --------------------------------------------------------------------------------------------- */