lib/vfs/interface.c

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