lib/vfs/path.c

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