lib/vfs/path.c

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