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