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