lib/vfs/interface.c

   1 /*
   2    Virtual File System: interface functions
   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 <stdio.h>
  37 #include <stdlib.h>             /* For atol() */
  38 #include <stdarg.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <sys/types.h>
  42 #include <signal.h>
  43 #include <ctype.h>              /* is_digit() */
  44 #include <fcntl.h>
  45 #include <sys/stat.h>
  46 #include <unistd.h>
  47 #include <dirent.h>
  48
  49 #include "lib/global.h"
  50
  51 #include "lib/widget.h"         /* message() */
  52 #include "lib/strutil.h"        /* str_crt_conv_from() */
  53
  54 #include "vfs.h"
  55 #include "utilvfs.h"
  56 #include "path.h"
  57 #include "gc.h"
  58
  59 extern GString *vfs_str_buffer;
  60 extern struct vfs_class *current_vfs;
  61
  62 /*** global variables ****************************************************************************/
  63
  64 struct dirent *mc_readdir_result = NULL;
  65
  66 /*** file scope macro definitions ****************************************************************/
  67
  68 /*** file scope type declarations ****************************************************************/
  69
  70 /*** file scope variables ************************************************************************/
  71
  72 /*** file scope functions ************************************************************************/
  73 /* --------------------------------------------------------------------------------------------- */
  74
  75 static char *
  76 mc_def_getlocalcopy (const char *filename)
  77 {
  78     char *tmp;
  79     int fdin, fdout;
  80     ssize_t i;
  81     char buffer[8192];
  82     struct stat mystat;
  83
  84     fdin = mc_open (filename, O_RDONLY | O_LINEAR);
  85     if (fdin == -1)
  86         return NULL;
  87
  88     fdout = vfs_mkstemps (&tmp, "vfs", filename);
  89
  90     if (fdout == -1)
  91         goto fail;
  92     while ((i = mc_read (fdin, buffer, sizeof (buffer))) > 0)
  93     {
  94         if (write (fdout, buffer, i) != i)
  95             goto fail;
  96     }
  97     if (i == -1)
  98         goto fail;
  99     i = mc_close (fdin);
 100     fdin = -1;
 101     if (i == -1)
 102         goto fail;
 103     if (close (fdout) == -1)
 104     {
 105         fdout = -1;
 106         goto fail;
 107     }
 108
 109     if (mc_stat (filename, &mystat) != -1)
 110         chmod (tmp, mystat.st_mode);
 111
 112     return tmp;
 113
 114   fail:
 115     if (fdout != -1)
 116         close (fdout);
 117     if (fdin != -1)
 118         mc_close (fdin);
 119     g_free (tmp);
 120     return NULL;
 121 }
 122
 123 /* --------------------------------------------------------------------------------------------- */
 124
 125 static int
 126 mc_def_ungetlocalcopy (struct vfs_class *vfs, const char *filename,
 127                        const char *local, int has_changed)
 128 {
 129     int fdin = -1, fdout = -1;
 130     if (has_changed)
 131     {
 132         char buffer[8192];
 133         ssize_t i;
 134
 135         if (!vfs->write)
 136             goto failed;
 137
 138         fdin = open (local, O_RDONLY);
 139         if (fdin == -1)
 140             goto failed;
 141         fdout = mc_open (filename, O_WRONLY | O_TRUNC);
 142         if (fdout == -1)
 143             goto failed;
 144         while ((i = read (fdin, buffer, sizeof (buffer))) > 0)
 145             if (mc_write (fdout, buffer, (size_t) i) != i)
 146                 goto failed;
 147         if (i == -1)
 148             goto failed;
 149
 150         if (close (fdin) == -1)
 151         {
 152             fdin = -1;
 153             goto failed;
 154         }
 155         fdin = -1;
 156         if (mc_close (fdout) == -1)
 157         {
 158             fdout = -1;
 159             goto failed;
 160         }
 161     }
 162     unlink (local);
 163     return 0;
 164
 165   failed:
 166     message (D_ERROR, _("Changes to file lost"), "%s", filename);
 167     if (fdout != -1)
 168         mc_close (fdout);
 169     if (fdin != -1)
 170         close (fdin);
 171     unlink (local);
 172     return -1;
 173 }
 174
 175 /* --------------------------------------------------------------------------------------------- */
 176 /*** public functions ****************************************************************************/
 177 /* --------------------------------------------------------------------------------------------- */
 178
 179 int
 180 mc_open (const char *filename, int flags, ...)
 181 {
 182     int mode = 0, result = -1;
 183     vfs_path_t *vpath;
 184     vfs_path_element_t *path_element;
 185
 186     vpath = vfs_path_from_str (filename);
 187     if (vpath == NULL)
 188         return -1;
 189
 190     /* Get the mode flag */
 191     if (flags & O_CREAT)
 192     {
 193         va_list ap;
 194         va_start (ap, flags);
 195         mode = va_arg (ap, int);
 196         va_end (ap);
 197     }
 198
 199     path_element = vfs_path_get_by_index (vpath, -1);
 200     if (vfs_path_element_valid (path_element) && path_element->class->open != NULL)
 201     {
 202         void *info;
 203         /* open must be supported */
 204         info = path_element->class->open (vpath, flags, mode);
 205         if (info == NULL)
 206             errno = vfs_ferrno (path_element->class);
 207         else
 208             result = vfs_new_handle (path_element->class, info);
 209     }
 210     else
 211         errno = -EOPNOTSUPP;
 212
 213     vfs_path_free (vpath);
 214     return result;
 215 }
 216
 217 /* --------------------------------------------------------------------------------------------- */
 218
 219 /* *INDENT-OFF* */
 220
 221 #define MC_NAMEOP(name, inarg, callarg) \
 222 int mc_##name inarg \
 223 { \
 224     int result; \
 225     vfs_path_t *vpath; \
 226     vfs_path_element_t *path_element; \
 227 \
 228     vpath = vfs_path_from_str (path); \
 229     if (vpath == NULL) \
 230         return -1; \
 231 \
 232     path_element = vfs_path_get_by_index (vpath, -1); \
 233     if (!vfs_path_element_valid (path_element)) \
 234     { \
 235         vfs_path_free(vpath); \
 236         return -1; \
 237     } \
 238 \
 239     result = path_element->class->name != NULL ? path_element->class->name callarg : -1; \
 240     if (result == -1) \
 241         errno = path_element->class->name != NULL ? vfs_ferrno (path_element->class) : E_NOTSUPP; \
 242     vfs_path_free(vpath); \
 243     return result; \
 244 }
 245
 246 MC_NAMEOP (chmod, (const char *path, mode_t mode), (vpath, mode))
 247 MC_NAMEOP (chown, (const char *path, uid_t owner, gid_t group), (vpath, owner, group))
 248 MC_NAMEOP (utime, (const char *path, struct utimbuf * times), (vpath, times))
 249 MC_NAMEOP (readlink, (const char *path, char *buf, size_t bufsiz), (vpath, buf, bufsiz))
 250 MC_NAMEOP (unlink, (const char *path), (vpath))
 251 MC_NAMEOP (mkdir, (const char *path, mode_t mode), (vpath, mode))
 252 MC_NAMEOP (rmdir, (const char *path), (vpath))
 253 MC_NAMEOP (mknod, (const char *path, mode_t mode, dev_t dev), (vpath, mode, dev))
 254
 255 /* *INDENT-ON* */
 256
 257 /* --------------------------------------------------------------------------------------------- */
 258
 259 int
 260 mc_symlink (const char *name1, const char *path)
 261 {
 262     int result = -1;
 263     vfs_path_t *vpath1, *vpath2;
 264
 265     vpath1 = vfs_path_from_str (path);
 266     if (vpath1 == NULL)
 267         return -1;
 268
 269     vpath2 = vfs_path_from_str_flags (name1, VPF_NO_CANON);
 270
 271     if (vpath2 != NULL)
 272     {
 273         vfs_path_element_t *path_element = vfs_path_get_by_index (vpath1, -1);
 274         if (vfs_path_element_valid (path_element))
 275         {
 276             result =
 277                 path_element->class->symlink !=
 278                 NULL ? path_element->class->symlink (vpath2, vpath1) : -1;
 279
 280             if (result == -1)
 281                 errno =
 282                     path_element->class->symlink !=
 283                     NULL ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 284         }
 285     }
 286     vfs_path_free (vpath1);
 287     vfs_path_free (vpath2);
 288     return result;
 289 }
 290
 291 /* --------------------------------------------------------------------------------------------- */
 292
 293 /* *INDENT-OFF* */
 294
 295 #define MC_HANDLEOP(name, inarg, callarg) \
 296 ssize_t mc_##name inarg \
 297 { \
 298     struct vfs_class *vfs; \
 299     int result; \
 300     if (handle == -1) \
 301         return -1; \
 302     vfs = vfs_class_find_by_handle (handle); \
 303     if (vfs == NULL) \
 304         return -1; \
 305     result = vfs->name != NULL ? vfs->name callarg : -1; \
 306     if (result == -1) \
 307         errno = vfs->name != NULL ? vfs_ferrno (vfs) : E_NOTSUPP; \
 308     return result; \
 309 }
 310
 311 MC_HANDLEOP (read, (int handle, void *buffer, size_t count), (vfs_class_data_find_by_handle (handle), buffer, count))
 312 MC_HANDLEOP (write, (int handle, const void *buf, size_t nbyte), (vfs_class_data_find_by_handle (handle), buf, nbyte))
 313
 314 /* --------------------------------------------------------------------------------------------- */
 315
 316 #define MC_RENAMEOP(name) \
 317 int mc_##name (const char *fname1, const char *fname2) \
 318 { \
 319     int result; \
 320     vfs_path_t *vpath1, *vpath2; \
 321     vfs_path_element_t *path_element1, *path_element2; \
 322 \
 323     vpath1 = vfs_path_from_str (fname1); \
 324     if (vpath1 == NULL) \
 325         return -1; \
 326 \
 327     vpath2 = vfs_path_from_str (fname2); \
 328     if (vpath2 == NULL) \
 329     { \
 330         vfs_path_free(vpath1); \
 331         return -1; \
 332     }\
 333     path_element1 = vfs_path_get_by_index (vpath1, - 1); \
 334     path_element2 = vfs_path_get_by_index (vpath2, - 1); \
 335 \
 336     if (!vfs_path_element_valid (path_element1) || !vfs_path_element_valid (path_element2) || \
 337         path_element1->class != path_element2->class) \
 338     { \
 339         errno = EXDEV; \
 340         vfs_path_free(vpath1); \
 341         vfs_path_free(vpath2); \
 342         return -1; \
 343     }\
 344 \
 345     result = path_element1->class->name != NULL \
 346         ? path_element1->class->name (vpath1, vpath2) \
 347         : -1; \
 348     if (result == -1) \
 349         errno = path_element1->class->name != NULL ? vfs_ferrno (path_element1->class) : E_NOTSUPP; \
 350     vfs_path_free(vpath1); \
 351     vfs_path_free(vpath2); \
 352     return result; \
 353 }
 354
 355 MC_RENAMEOP (link)
 356 MC_RENAMEOP (rename)
 357
 358 /* *INDENT-ON* */
 359
 360 /* --------------------------------------------------------------------------------------------- */
 361
 362 int
 363 mc_ctl (int handle, int ctlop, void *arg)
 364 {
 365     struct vfs_class *vfs = vfs_class_find_by_handle (handle);
 366
 367     if (vfs == NULL)
 368         return 0;
 369
 370     return vfs->ctl ? (*vfs->ctl) (vfs_class_data_find_by_handle (handle), ctlop, arg) : 0;
 371 }
 372
 373 /* --------------------------------------------------------------------------------------------- */
 374
 375 int
 376 mc_setctl (const char *path, int ctlop, void *arg)
 377 {
 378     int result = -1;
 379
 380     vfs_path_t *vpath;
 381     vfs_path_element_t *path_element;
 382
 383     vpath = vfs_path_from_str (path);
 384     if (vpath == NULL)
 385         vfs_die ("You don't want to pass NULL to mc_setctl.");
 386
 387     path_element = vfs_path_get_by_index (vpath, -1);
 388     if (vfs_path_element_valid (path_element))
 389         result =
 390             path_element->class->setctl != NULL ? path_element->class->setctl (vpath,
 391                                                                                ctlop, arg) : 0;
 392
 393     vfs_path_free (vpath);
 394     return result;
 395 }
 396
 397 /* --------------------------------------------------------------------------------------------- */
 398
 399 int
 400 mc_close (int handle)
 401 {
 402     struct vfs_class *vfs;
 403     int result;
 404
 405     if (handle == -1 || !vfs_class_data_find_by_handle (handle))
 406         return -1;
 407
 408     vfs = vfs_class_find_by_handle (handle);
 409     if (vfs == NULL)
 410         return -1;
 411
 412     if (handle < 3)
 413         return close (handle);
 414
 415     if (!vfs->close)
 416         vfs_die ("VFS must support close.\n");
 417     result = (*vfs->close) (vfs_class_data_find_by_handle (handle));
 418     vfs_free_handle (handle);
 419     if (result == -1)
 420         errno = vfs_ferrno (vfs);
 421
 422     return result;
 423 }
 424
 425 /* --------------------------------------------------------------------------------------------- */
 426
 427 DIR *
 428 mc_opendir (const char *dirname)
 429 {
 430     int handle, *handlep;
 431     void *info;
 432     vfs_path_t *vpath;
 433     vfs_path_element_t *path_element;
 434
 435     vpath = vfs_path_from_str (dirname);
 436
 437     if (vpath == NULL)
 438         return NULL;
 439
 440     path_element = vfs_path_get_by_index (vpath, -1);
 441
 442     if (!vfs_path_element_valid (path_element))
 443     {
 444         errno = E_NOTSUPP;
 445         vfs_path_free (vpath);
 446         return NULL;
 447     }
 448
 449     info = path_element->class->opendir ? (*path_element->class->opendir) (vpath) : NULL;
 450
 451     if (info == NULL)
 452     {
 453         errno = path_element->class->opendir ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 454         vfs_path_free (vpath);
 455         return NULL;
 456     }
 457
 458     path_element->dir.info = info;
 459
 460     path_element->dir.converter =
 461         (path_element->encoding !=
 462          NULL) ? str_crt_conv_from (path_element->encoding) : str_cnv_from_term;
 463     if (path_element->dir.converter == INVALID_CONV)
 464         path_element->dir.converter = str_cnv_from_term;
 465
 466     handle = vfs_new_handle (path_element->class, vfs_path_element_clone (path_element));
 467
 468     handlep = g_new (int, 1);
 469     *handlep = handle;
 470     vfs_path_free (vpath);
 471     return (DIR *) handlep;
 472 }
 473
 474 /* --------------------------------------------------------------------------------------------- */
 475
 476 struct dirent *
 477 mc_readdir (DIR * dirp)
 478 {
 479     int handle;
 480     struct vfs_class *vfs;
 481     struct dirent *entry = NULL;
 482     vfs_path_element_t *vfs_path_element;
 483     estr_t state;
 484
 485     if (!mc_readdir_result)
 486     {
 487         /* We can't just allocate struct dirent as (see man dirent.h)
 488          * struct dirent has VERY nonnaive semantics of allocating
 489          * d_name in it. Moreover, linux's glibc-2.9 allocates dirents _less_,
 490          * than 'sizeof (struct dirent)' making full bitwise (sizeof dirent) copy
 491          * heap corrupter. So, allocate longliving dirent with at least
 492          * (MAXNAMLEN + 1) for d_name in it.
 493          * Strictly saying resulting dirent is unusable as we don't adjust internal
 494          * structures, holding dirent size. But we don't use it in libc infrastructure.
 495          * TODO: to make simpler homemade dirent-alike structure.
 496          */
 497         mc_readdir_result = (struct dirent *) g_malloc (sizeof (struct dirent) + MAXNAMLEN + 1);
 498     }
 499
 500     if (!dirp)
 501     {
 502         errno = EFAULT;
 503         return NULL;
 504     }
 505     handle = *(int *) dirp;
 506
 507     vfs = vfs_class_find_by_handle (handle);
 508     if (vfs == NULL)
 509         return NULL;
 510
 511     vfs_path_element = vfs_class_data_find_by_handle (handle);
 512     if (vfs->readdir)
 513     {
 514         entry = (*vfs->readdir) (vfs_path_element->dir.info);
 515         if (entry == NULL)
 516             return NULL;
 517         g_string_set_size (vfs_str_buffer, 0);
 518         state =
 519             str_vfs_convert_from (vfs_path_element->dir.converter, entry->d_name, vfs_str_buffer);
 520         mc_readdir_result->d_ino = entry->d_ino;
 521         g_strlcpy (mc_readdir_result->d_name, vfs_str_buffer->str, MAXNAMLEN + 1);
 522     }
 523     if (entry == NULL)
 524         errno = vfs->readdir ? vfs_ferrno (vfs) : E_NOTSUPP;
 525     return (entry != NULL) ? mc_readdir_result : NULL;
 526 }
 527
 528 /* --------------------------------------------------------------------------------------------- */
 529
 530 int
 531 mc_closedir (DIR * dirp)
 532 {
 533     int handle = *(int *) dirp;
 534     struct vfs_class *vfs;
 535     int result = -1;
 536
 537     vfs = vfs_class_find_by_handle (handle);
 538     if (vfs != NULL)
 539     {
 540         vfs_path_element_t *vfs_path_element;
 541         vfs_path_element = vfs_class_data_find_by_handle (handle);
 542         if (vfs_path_element->dir.converter != str_cnv_from_term)
 543         {
 544             str_close_conv (vfs_path_element->dir.converter);
 545             vfs_path_element->dir.converter = INVALID_CONV;
 546         }
 547
 548         result = vfs->closedir ? (*vfs->closedir) (vfs_path_element->dir.info) : -1;
 549         vfs_free_handle (handle);
 550         vfs_path_element_free (vfs_path_element);
 551     }
 552     g_free (dirp);
 553     return result;
 554 }
 555
 556 /* --------------------------------------------------------------------------------------------- */
 557
 558 int
 559 mc_stat (const char *filename, struct stat *buf)
 560 {
 561     int result = -1;
 562     vfs_path_t *vpath;
 563     vfs_path_element_t *path_element;
 564
 565     vpath = vfs_path_from_str (filename);
 566     if (vpath == NULL)
 567         return -1;
 568
 569     path_element = vfs_path_get_by_index (vpath, -1);
 570
 571     if (vfs_path_element_valid (path_element))
 572     {
 573         result = path_element->class->stat ? (*path_element->class->stat) (vpath, buf) : -1;
 574         if (result == -1)
 575             errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 576     }
 577
 578     vfs_path_free (vpath);
 579     return result;
 580 }
 581
 582 /* --------------------------------------------------------------------------------------------- */
 583
 584 int
 585 mc_lstat (const char *filename, struct stat *buf)
 586 {
 587     int result = -1;
 588     vfs_path_t *vpath;
 589     vfs_path_element_t *path_element;
 590
 591     vpath = vfs_path_from_str (filename);
 592     if (vpath == NULL)
 593         return -1;
 594
 595     path_element = vfs_path_get_by_index (vpath, -1);
 596
 597     if (vfs_path_element_valid (path_element))
 598     {
 599         result = path_element->class->lstat ? (*path_element->class->lstat) (vpath, buf) : -1;
 600         if (result == -1)
 601             errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 602     }
 603
 604     vfs_path_free (vpath);
 605     return result;
 606 }
 607
 608 /* --------------------------------------------------------------------------------------------- */
 609
 610 int
 611 mc_fstat (int handle, struct stat *buf)
 612 {
 613     struct vfs_class *vfs;
 614     int result;
 615
 616     if (handle == -1)
 617         return -1;
 618
 619     vfs = vfs_class_find_by_handle (handle);
 620     if (vfs == NULL)
 621         return -1;
 622
 623     result = vfs->fstat ? (*vfs->fstat) (vfs_class_data_find_by_handle (handle), buf) : -1;
 624     if (result == -1)
 625         errno = vfs->name ? vfs_ferrno (vfs) : E_NOTSUPP;
 626     return result;
 627 }
 628
 629 /* --------------------------------------------------------------------------------------------- */
 630 /**
 631  * Return current directory. If it's local, reread the current directory
 632  * from the OS. Put directory to the provided buffer.
 633  */
 634
 635 char *
 636 mc_get_current_wd (char *buffer, size_t size)
 637 {
 638     char *cwd = _vfs_get_cwd ();
 639
 640     g_strlcpy (buffer, cwd, size);
 641     g_free (cwd);
 642
 643     return buffer;
 644 }
 645
 646 /* --------------------------------------------------------------------------------------------- */
 647
 648 char *
 649 mc_getlocalcopy (const char *pathname)
 650 {
 651     char *result = NULL;
 652     vfs_path_t *vpath;
 653     vfs_path_element_t *path_element;
 654
 655     vpath = vfs_path_from_str (pathname);
 656     if (vpath == NULL)
 657         return NULL;
 658
 659     path_element = vfs_path_get_by_index (vpath, -1);
 660
 661     if (vfs_path_element_valid (path_element))
 662     {
 663         result = path_element->class->getlocalcopy != NULL ?
 664             path_element->class->getlocalcopy (vpath) : mc_def_getlocalcopy (pathname);
 665         if (result == NULL)
 666             errno = vfs_ferrno (path_element->class);
 667     }
 668     vfs_path_free (vpath);
 669     return result;
 670 }
 671
 672 /* --------------------------------------------------------------------------------------------- */
 673
 674 int
 675 mc_ungetlocalcopy (const char *pathname, const char *local, int has_changed)
 676 {
 677     int return_value = -1;
 678     vfs_path_t *vpath;
 679     vfs_path_element_t *path_element;
 680
 681     vpath = vfs_path_from_str (pathname);
 682     if (vpath == NULL)
 683         return -1;
 684
 685     path_element = vfs_path_get_by_index (vpath, -1);
 686
 687     if (vfs_path_element_valid (path_element))
 688     {
 689         return_value = path_element->class->ungetlocalcopy != NULL ?
 690             path_element->class->ungetlocalcopy (vpath, local,
 691                                                  has_changed) :
 692             mc_def_ungetlocalcopy (path_element->class, path_element->path, local, has_changed);
 693     }
 694     vfs_path_free (vpath);
 695     return return_value;
 696 }
 697
 698 /* --------------------------------------------------------------------------------------------- */
 699 /**
 700  * VFS chdir.
 701  * Return 0 on success, -1 on failure.
 702  */
 703
 704 int
 705 mc_chdir (const char *path)
 706 {
 707     struct vfs_class *old_vfs;
 708     vfsid old_vfsid;
 709     int result;
 710     vfs_path_t *vpath;
 711     vfs_path_element_t *path_element;
 712
 713     vpath = vfs_path_from_str (path);
 714
 715     if (vpath == NULL)
 716         return -1;
 717
 718     path_element = vfs_path_get_by_index (vpath, -1);
 719
 720     if (!vfs_path_element_valid (path_element) || path_element->class->chdir == NULL)
 721     {
 722         vfs_path_free (vpath);
 723         return -1;
 724     }
 725
 726     result = (*path_element->class->chdir) (vpath);
 727
 728     if (result == -1)
 729     {
 730         errno = vfs_ferrno (path_element->class);
 731         vfs_path_free (vpath);
 732         return -1;
 733     }
 734
 735     old_vfsid = vfs_getid (vfs_get_raw_current_dir ());
 736     old_vfs = current_vfs;
 737
 738     /* Actually change directory */
 739     vfs_set_raw_current_dir (vpath);
 740     current_vfs = path_element->class;
 741
 742     /* This function uses the new current_dir implicitly */
 743     vfs_stamp_create (old_vfs, old_vfsid);
 744
 745     /* Sometimes we assume no trailing slash on cwd */
 746     path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
 747     if (vfs_path_element_valid (path_element) && (*path_element->path != '\0'))
 748     {
 749         char *p;
 750         p = strchr (path_element->path, 0) - 1;
 751         if (*p == PATH_SEP && p > path_element->path)
 752             *p = 0;
 753     }
 754     return 0;
 755 }
 756
 757 /* --------------------------------------------------------------------------------------------- */
 758
 759 off_t
 760 mc_lseek (int fd, off_t offset, int whence)
 761 {
 762     struct vfs_class *vfs;
 763     off_t result;
 764
 765     if (fd == -1)
 766         return -1;
 767
 768     vfs = vfs_class_find_by_handle (fd);
 769     if (vfs == NULL)
 770         return -1;
 771
 772     result = vfs->lseek ? (*vfs->lseek) (vfs_class_data_find_by_handle (fd), offset, whence) : -1;
 773     if (result == -1)
 774         errno = vfs->lseek ? vfs_ferrno (vfs) : E_NOTSUPP;
 775     return result;
 776 }
 777
 778 /* --------------------------------------------------------------------------------------------- */