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 #include <pwd.h>
  49 #include <grp.h>
  50
  51 #include "lib/global.h"
  52
  53 #include "lib/widget.h"         /* message() */
  54 #include "lib/strutil.h"        /* str_crt_conv_from() */
  55 #include "lib/util.h"
  56
  57 #include "vfs.h"
  58 #include "utilvfs.h"
  59 #include "path.h"
  60 #include "gc.h"
  61
  62 extern GString *vfs_str_buffer;
  63 extern struct vfs_class *current_vfs;
  64
  65 /*** global variables ****************************************************************************/
  66
  67 struct dirent *mc_readdir_result = NULL;
  68
  69 /*** file scope macro definitions ****************************************************************/
  70
  71 /*** file scope type declarations ****************************************************************/
  72
  73 /*** file scope variables ************************************************************************/
  74
  75 /*** file scope functions ************************************************************************/
  76 /* --------------------------------------------------------------------------------------------- */
  77
  78 static char *
  79 mc_def_getlocalcopy (const char *filename)
  80 {
  81     char *tmp = NULL;
  82     int fdin = -1, fdout = -1;
  83     ssize_t i;
  84     char buffer[BUF_1K * 8];
  85     struct stat mystat;
  86     vfs_path_t *vpath;
  87
  88     vpath = vfs_path_from_str (filename);
  89     fdin = mc_open (vpath, O_RDONLY | O_LINEAR);
  90     if (fdin == -1)
  91         goto fail;
  92
  93     fdout = vfs_mkstemps (&tmp, "vfs", filename);
  94     if (fdout == -1)
  95         goto fail;
  96
  97     while ((i = mc_read (fdin, buffer, sizeof (buffer))) > 0)
  98     {
  99         if (write (fdout, buffer, i) != i)
 100             goto fail;
 101     }
 102     if (i == -1)
 103         goto fail;
 104     i = mc_close (fdin);
 105     fdin = -1;
 106     if (i == -1)
 107         goto fail;
 108     if (close (fdout) == -1)
 109     {
 110         fdout = -1;
 111         goto fail;
 112     }
 113
 114     if (mc_stat (vpath, &mystat) != -1)
 115         chmod (tmp, mystat.st_mode);
 116     vfs_path_free (vpath);
 117
 118     return tmp;
 119
 120   fail:
 121     vfs_path_free (vpath);
 122     if (fdout != -1)
 123         close (fdout);
 124     if (fdin != -1)
 125         mc_close (fdin);
 126     g_free (tmp);
 127     return NULL;
 128 }
 129
 130 /* --------------------------------------------------------------------------------------------- */
 131
 132 static int
 133 mc_def_ungetlocalcopy (struct vfs_class *vfs, const char *filename,
 134                        const char *local, int has_changed)
 135 {
 136     vfs_path_t *vpath;
 137     int fdin = -1, fdout = -1;
 138
 139     vpath = vfs_path_from_str (filename);
 140
 141     if (has_changed)
 142     {
 143         char buffer[BUF_1K * 8];
 144         ssize_t i;
 145
 146         if (!vfs->write)
 147             goto failed;
 148
 149         fdin = open (local, O_RDONLY);
 150         if (fdin == -1)
 151             goto failed;
 152         fdout = mc_open (vpath, O_WRONLY | O_TRUNC);
 153         if (fdout == -1)
 154             goto failed;
 155         while ((i = read (fdin, buffer, sizeof (buffer))) > 0)
 156             if (mc_write (fdout, buffer, (size_t) i) != i)
 157                 goto failed;
 158         if (i == -1)
 159             goto failed;
 160
 161         if (close (fdin) == -1)
 162         {
 163             fdin = -1;
 164             goto failed;
 165         }
 166         fdin = -1;
 167         if (mc_close (fdout) == -1)
 168         {
 169             fdout = -1;
 170             goto failed;
 171         }
 172     }
 173     unlink (local);
 174     vfs_path_free (vpath);
 175     return 0;
 176
 177   failed:
 178     message (D_ERROR, _("Changes to file lost"), "%s", filename);
 179     if (fdout != -1)
 180         mc_close (fdout);
 181     if (fdin != -1)
 182         close (fdin);
 183     unlink (local);
 184     vfs_path_free (vpath);
 185     return -1;
 186 }
 187
 188 /* --------------------------------------------------------------------------------------------- */
 189 /*** public functions ****************************************************************************/
 190 /* --------------------------------------------------------------------------------------------- */
 191
 192 int
 193 mc_open (const vfs_path_t * vpath, int flags, ...)
 194 {
 195     int mode = 0, result = -1;
 196     vfs_path_element_t *path_element;
 197
 198     if (vpath == NULL)
 199         return -1;
 200
 201     /* Get the mode flag */
 202     if (flags & O_CREAT)
 203     {
 204         va_list ap;
 205         va_start (ap, flags);
 206         mode = va_arg (ap, int);
 207         va_end (ap);
 208     }
 209
 210     path_element = vfs_path_get_by_index (vpath, -1);
 211     if (vfs_path_element_valid (path_element) && path_element->class->open != NULL)
 212     {
 213         void *info;
 214         /* open must be supported */
 215         info = path_element->class->open (vpath, flags, mode);
 216         if (info == NULL)
 217             errno = vfs_ferrno (path_element->class);
 218         else
 219             result = vfs_new_handle (path_element->class, info);
 220     }
 221     else
 222         errno = -EOPNOTSUPP;
 223
 224     return result;
 225 }
 226
 227 /* --------------------------------------------------------------------------------------------- */
 228
 229 /* *INDENT-OFF* */
 230
 231 #define MC_NAMEOP(name, inarg, callarg) \
 232 int mc_##name inarg \
 233 { \
 234     int result; \
 235     vfs_path_element_t *path_element; \
 236 \
 237     if (vpath == NULL) \
 238         return -1; \
 239 \
 240     path_element = vfs_path_get_by_index (vpath, -1); \
 241     if (!vfs_path_element_valid (path_element)) \
 242     { \
 243         return -1; \
 244     } \
 245 \
 246     result = path_element->class->name != NULL ? path_element->class->name callarg : -1; \
 247     if (result == -1) \
 248         errno = path_element->class->name != NULL ? vfs_ferrno (path_element->class) : E_NOTSUPP; \
 249     return result; \
 250 }
 251
 252 MC_NAMEOP (chmod, (const vfs_path_t *vpath, mode_t mode), (vpath, mode))
 253 MC_NAMEOP (chown, (const vfs_path_t *vpath, uid_t owner, gid_t group), (vpath, owner, group))
 254 MC_NAMEOP (utime, (const vfs_path_t *vpath, struct utimbuf * times), (vpath, times))
 255 MC_NAMEOP (readlink, (const vfs_path_t *vpath, char *buf, size_t bufsiz), (vpath, buf, bufsiz))
 256 MC_NAMEOP (unlink, (const vfs_path_t *vpath), (vpath))
 257 MC_NAMEOP (mkdir, (const vfs_path_t *vpath, mode_t mode), (vpath, mode))
 258 MC_NAMEOP (rmdir, (const vfs_path_t *vpath), (vpath))
 259 MC_NAMEOP (mknod, (const vfs_path_t *vpath, mode_t mode, dev_t dev), (vpath, mode, dev))
 260
 261 /* *INDENT-ON* */
 262
 263 /* --------------------------------------------------------------------------------------------- */
 264
 265 int
 266 mc_symlink (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
 267 {
 268     int result = -1;
 269
 270     if (vpath1 == NULL)
 271         return -1;
 272
 273     if (vpath1 != NULL)
 274     {
 275         vfs_path_element_t *path_element;
 276
 277         path_element = vfs_path_get_by_index (vpath2, -1);
 278         if (vfs_path_element_valid (path_element))
 279         {
 280             result =
 281                 path_element->class->symlink != NULL ?
 282                 path_element->class->symlink (vpath1, vpath2) : -1;
 283
 284             if (result == -1)
 285                 errno =
 286                     path_element->class->symlink != NULL ?
 287                     vfs_ferrno (path_element->class) : E_NOTSUPP;
 288         }
 289     }
 290     return result;
 291 }
 292
 293 /* --------------------------------------------------------------------------------------------- */
 294
 295 /* *INDENT-OFF* */
 296
 297 #define MC_HANDLEOP(name, inarg, callarg) \
 298 ssize_t mc_##name inarg \
 299 { \
 300     struct vfs_class *vfs; \
 301     int result; \
 302     if (handle == -1) \
 303         return -1; \
 304     vfs = vfs_class_find_by_handle (handle); \
 305     if (vfs == NULL) \
 306         return -1; \
 307     result = vfs->name != NULL ? vfs->name callarg : -1; \
 308     if (result == -1) \
 309         errno = vfs->name != NULL ? vfs_ferrno (vfs) : E_NOTSUPP; \
 310     return result; \
 311 }
 312
 313 MC_HANDLEOP (read, (int handle, void *buffer, size_t count), (vfs_class_data_find_by_handle (handle), buffer, count))
 314 MC_HANDLEOP (write, (int handle, const void *buf, size_t nbyte), (vfs_class_data_find_by_handle (handle), buf, nbyte))
 315
 316 /* --------------------------------------------------------------------------------------------- */
 317
 318 #define MC_RENAMEOP(name) \
 319 int mc_##name (const vfs_path_t *vpath1, const vfs_path_t *vpath2) \
 320 { \
 321     int result; \
 322     vfs_path_element_t *path_element1, *path_element2; \
 323 \
 324     if (vpath1 == NULL || vpath2 == NULL) \
 325         return -1; \
 326 \
 327     path_element1 = vfs_path_get_by_index (vpath1, - 1); \
 328     path_element2 = vfs_path_get_by_index (vpath2, - 1); \
 329 \
 330     if (!vfs_path_element_valid (path_element1) || !vfs_path_element_valid (path_element2) || \
 331         path_element1->class != path_element2->class) \
 332     { \
 333         errno = EXDEV; \
 334         return -1; \
 335     }\
 336 \
 337     result = path_element1->class->name != NULL \
 338         ? path_element1->class->name (vpath1, vpath2) \
 339         : -1; \
 340     if (result == -1) \
 341         errno = path_element1->class->name != NULL ? vfs_ferrno (path_element1->class) : E_NOTSUPP; \
 342     return result; \
 343 }
 344
 345 MC_RENAMEOP (link)
 346 MC_RENAMEOP (rename)
 347
 348 /* *INDENT-ON* */
 349
 350 /* --------------------------------------------------------------------------------------------- */
 351
 352 int
 353 mc_ctl (int handle, int ctlop, void *arg)
 354 {
 355     struct vfs_class *vfs = vfs_class_find_by_handle (handle);
 356
 357     if (vfs == NULL)
 358         return 0;
 359
 360     return vfs->ctl ? (*vfs->ctl) (vfs_class_data_find_by_handle (handle), ctlop, arg) : 0;
 361 }
 362
 363 /* --------------------------------------------------------------------------------------------- */
 364
 365 int
 366 mc_setctl (const vfs_path_t * vpath, int ctlop, void *arg)
 367 {
 368     int result = -1;
 369
 370     vfs_path_element_t *path_element;
 371
 372     if (vpath == NULL)
 373         vfs_die ("You don't want to pass NULL to mc_setctl.");
 374
 375     path_element = vfs_path_get_by_index (vpath, -1);
 376     if (vfs_path_element_valid (path_element))
 377         result =
 378             path_element->class->setctl != NULL ? path_element->class->setctl (vpath,
 379                                                                                ctlop, arg) : 0;
 380
 381     return result;
 382 }
 383
 384 /* --------------------------------------------------------------------------------------------- */
 385
 386 int
 387 mc_close (int handle)
 388 {
 389     struct vfs_class *vfs;
 390     int result;
 391
 392     if (handle == -1 || !vfs_class_data_find_by_handle (handle))
 393         return -1;
 394
 395     vfs = vfs_class_find_by_handle (handle);
 396     if (vfs == NULL)
 397         return -1;
 398
 399     if (handle < 3)
 400         return close (handle);
 401
 402     if (!vfs->close)
 403         vfs_die ("VFS must support close.\n");
 404     result = (*vfs->close) (vfs_class_data_find_by_handle (handle));
 405     vfs_free_handle (handle);
 406     if (result == -1)
 407         errno = vfs_ferrno (vfs);
 408
 409     return result;
 410 }
 411
 412 /* --------------------------------------------------------------------------------------------- */
 413
 414 DIR *
 415 mc_opendir (const vfs_path_t * vpath)
 416 {
 417     int handle, *handlep;
 418     void *info;
 419     vfs_path_element_t *path_element;
 420
 421     if (vpath == NULL)
 422         return NULL;
 423
 424     path_element = vfs_path_get_by_index (vpath, -1);
 425
 426     if (!vfs_path_element_valid (path_element))
 427     {
 428         errno = E_NOTSUPP;
 429         return NULL;
 430     }
 431
 432     info = path_element->class->opendir ? (*path_element->class->opendir) (vpath) : NULL;
 433
 434     if (info == NULL)
 435     {
 436         errno = path_element->class->opendir ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 437         return NULL;
 438     }
 439
 440     path_element->dir.info = info;
 441
 442     path_element->dir.converter =
 443         (path_element->encoding !=
 444          NULL) ? str_crt_conv_from (path_element->encoding) : str_cnv_from_term;
 445     if (path_element->dir.converter == INVALID_CONV)
 446         path_element->dir.converter = str_cnv_from_term;
 447
 448     handle = vfs_new_handle (path_element->class, vfs_path_element_clone (path_element));
 449
 450     handlep = g_new (int, 1);
 451     *handlep = handle;
 452     return (DIR *) handlep;
 453 }
 454
 455 /* --------------------------------------------------------------------------------------------- */
 456
 457 struct dirent *
 458 mc_readdir (DIR * dirp)
 459 {
 460     int handle;
 461     struct vfs_class *vfs;
 462     struct dirent *entry = NULL;
 463     vfs_path_element_t *vfs_path_element;
 464     estr_t state;
 465
 466     if (!mc_readdir_result)
 467     {
 468         /* We can't just allocate struct dirent as (see man dirent.h)
 469          * struct dirent has VERY nonnaive semantics of allocating
 470          * d_name in it. Moreover, linux's glibc-2.9 allocates dirents _less_,
 471          * than 'sizeof (struct dirent)' making full bitwise (sizeof dirent) copy
 472          * heap corrupter. So, allocate longliving dirent with at least
 473          * (MAXNAMLEN + 1) for d_name in it.
 474          * Strictly saying resulting dirent is unusable as we don't adjust internal
 475          * structures, holding dirent size. But we don't use it in libc infrastructure.
 476          * TODO: to make simpler homemade dirent-alike structure.
 477          */
 478         mc_readdir_result = (struct dirent *) g_malloc (sizeof (struct dirent) + MAXNAMLEN + 1);
 479     }
 480
 481     if (!dirp)
 482     {
 483         errno = EFAULT;
 484         return NULL;
 485     }
 486     handle = *(int *) dirp;
 487
 488     vfs = vfs_class_find_by_handle (handle);
 489     if (vfs == NULL)
 490         return NULL;
 491
 492     vfs_path_element = vfs_class_data_find_by_handle (handle);
 493     if (vfs->readdir)
 494     {
 495         entry = (*vfs->readdir) (vfs_path_element->dir.info);
 496         if (entry == NULL)
 497             return NULL;
 498         g_string_set_size (vfs_str_buffer, 0);
 499         state =
 500             str_vfs_convert_from (vfs_path_element->dir.converter, entry->d_name, vfs_str_buffer);
 501         mc_readdir_result->d_ino = entry->d_ino;
 502         g_strlcpy (mc_readdir_result->d_name, vfs_str_buffer->str, MAXNAMLEN + 1);
 503     }
 504     if (entry == NULL)
 505         errno = vfs->readdir ? vfs_ferrno (vfs) : E_NOTSUPP;
 506     return (entry != NULL) ? mc_readdir_result : NULL;
 507 }
 508
 509 /* --------------------------------------------------------------------------------------------- */
 510
 511 int
 512 mc_closedir (DIR * dirp)
 513 {
 514     int handle = *(int *) dirp;
 515     struct vfs_class *vfs;
 516     int result = -1;
 517
 518     vfs = vfs_class_find_by_handle (handle);
 519     if (vfs != NULL)
 520     {
 521         vfs_path_element_t *vfs_path_element;
 522         vfs_path_element = vfs_class_data_find_by_handle (handle);
 523         if (vfs_path_element->dir.converter != str_cnv_from_term)
 524         {
 525             str_close_conv (vfs_path_element->dir.converter);
 526             vfs_path_element->dir.converter = INVALID_CONV;
 527         }
 528
 529         result = vfs->closedir ? (*vfs->closedir) (vfs_path_element->dir.info) : -1;
 530         vfs_free_handle (handle);
 531         vfs_path_element_free (vfs_path_element);
 532     }
 533     g_free (dirp);
 534     return result;
 535 }
 536
 537 /* --------------------------------------------------------------------------------------------- */
 538
 539 int
 540 mc_stat (const vfs_path_t * vpath, struct stat *buf)
 541 {
 542     int result = -1;
 543     vfs_path_element_t *path_element;
 544
 545     if (vpath == NULL)
 546         return -1;
 547
 548     path_element = vfs_path_get_by_index (vpath, -1);
 549
 550     if (vfs_path_element_valid (path_element))
 551     {
 552         result = path_element->class->stat ? (*path_element->class->stat) (vpath, buf) : -1;
 553         if (result == -1)
 554             errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 555     }
 556
 557     return result;
 558 }
 559
 560 /* --------------------------------------------------------------------------------------------- */
 561
 562 int
 563 mc_lstat (const vfs_path_t * vpath, struct stat *buf)
 564 {
 565     int result = -1;
 566     vfs_path_element_t *path_element;
 567
 568     if (vpath == NULL)
 569         return -1;
 570
 571     path_element = vfs_path_get_by_index (vpath, -1);
 572
 573     if (vfs_path_element_valid (path_element))
 574     {
 575         result = path_element->class->lstat ? (*path_element->class->lstat) (vpath, buf) : -1;
 576         if (result == -1)
 577             errno = path_element->class->name ? vfs_ferrno (path_element->class) : E_NOTSUPP;
 578     }
 579
 580     return result;
 581 }
 582
 583 /* --------------------------------------------------------------------------------------------- */
 584
 585 int
 586 mc_fstat (int handle, struct stat *buf)
 587 {
 588     struct vfs_class *vfs;
 589     int result;
 590
 591     if (handle == -1)
 592         return -1;
 593
 594     vfs = vfs_class_find_by_handle (handle);
 595     if (vfs == NULL)
 596         return -1;
 597
 598     result = vfs->fstat ? (*vfs->fstat) (vfs_class_data_find_by_handle (handle), buf) : -1;
 599     if (result == -1)
 600         errno = vfs->name ? vfs_ferrno (vfs) : E_NOTSUPP;
 601     return result;
 602 }
 603
 604 /* --------------------------------------------------------------------------------------------- */
 605 /**
 606  * Return current directory. If it's local, reread the current directory
 607  * from the OS. Put directory to the provided buffer.
 608  */
 609
 610 char *
 611 mc_get_current_wd (char *buffer, size_t size)
 612 {
 613     char *cwd = _vfs_get_cwd ();
 614
 615     g_strlcpy (buffer, cwd, size);
 616     g_free (cwd);
 617
 618     return buffer;
 619 }
 620
 621 /* --------------------------------------------------------------------------------------------- */
 622
 623 char *
 624 mc_getlocalcopy (const char *pathname)
 625 {
 626     char *result = NULL;
 627     vfs_path_t *vpath;
 628     vfs_path_element_t *path_element;
 629
 630     vpath = vfs_path_from_str (pathname);
 631     if (vpath == NULL)
 632         return NULL;
 633
 634     path_element = vfs_path_get_by_index (vpath, -1);
 635
 636     if (vfs_path_element_valid (path_element))
 637     {
 638         result = path_element->class->getlocalcopy != NULL ?
 639             path_element->class->getlocalcopy (vpath) : mc_def_getlocalcopy (pathname);
 640         if (result == NULL)
 641             errno = vfs_ferrno (path_element->class);
 642     }
 643     vfs_path_free (vpath);
 644     return result;
 645 }
 646
 647 /* --------------------------------------------------------------------------------------------- */
 648
 649 int
 650 mc_ungetlocalcopy (const char *pathname, const char *local, int has_changed)
 651 {
 652     int return_value = -1;
 653     vfs_path_t *vpath;
 654     vfs_path_element_t *path_element;
 655
 656     vpath = vfs_path_from_str (pathname);
 657     if (vpath == NULL)
 658         return -1;
 659
 660     path_element = vfs_path_get_by_index (vpath, -1);
 661
 662     if (vfs_path_element_valid (path_element))
 663     {
 664         return_value = path_element->class->ungetlocalcopy != NULL ?
 665             path_element->class->ungetlocalcopy (vpath, local,
 666                                                  has_changed) :
 667             mc_def_ungetlocalcopy (path_element->class, path_element->path, local, has_changed);
 668     }
 669     vfs_path_free (vpath);
 670     return return_value;
 671 }
 672
 673 /* --------------------------------------------------------------------------------------------- */
 674 /**
 675  * VFS chdir.
 676  *
 677  * @param vpath VFS-path
 678  *
 679  * @return 0 on success, -1 on failure.
 680  */
 681
 682 int
 683 mc_chdir (const vfs_path_t * vpath)
 684 {
 685     struct vfs_class *old_vfs;
 686     vfsid old_vfsid;
 687     int result;
 688     vfs_path_element_t *path_element;
 689
 690     if (vpath == NULL)
 691         return -1;
 692
 693     path_element = vfs_path_get_by_index (vpath, -1);
 694
 695     if (!vfs_path_element_valid (path_element) || path_element->class->chdir == NULL)
 696     {
 697         return -1;
 698     }
 699
 700     result = (*path_element->class->chdir) (vpath);
 701
 702     if (result == -1)
 703     {
 704         errno = vfs_ferrno (path_element->class);
 705         return -1;
 706     }
 707
 708     old_vfsid = vfs_getid (vfs_get_raw_current_dir ());
 709     old_vfs = current_vfs;
 710
 711     /* Actually change directory */
 712     vfs_set_raw_current_dir (vfs_path_clone (vpath));
 713     current_vfs = path_element->class;
 714
 715     /* This function uses the new current_dir implicitly */
 716     vfs_stamp_create (old_vfs, old_vfsid);
 717
 718     /* Sometimes we assume no trailing slash on cwd */
 719     path_element = vfs_path_get_by_index (vfs_get_raw_current_dir (), -1);
 720     if (vfs_path_element_valid (path_element) && (*path_element->path != '\0'))
 721     {
 722         char *p;
 723         p = strchr (path_element->path, 0) - 1;
 724         if (*p == PATH_SEP && p > path_element->path)
 725             *p = 0;
 726     }
 727     return 0;
 728 }
 729
 730 /* --------------------------------------------------------------------------------------------- */
 731
 732 off_t
 733 mc_lseek (int fd, off_t offset, int whence)
 734 {
 735     struct vfs_class *vfs;
 736     off_t result;
 737
 738     if (fd == -1)
 739         return -1;
 740
 741     vfs = vfs_class_find_by_handle (fd);
 742     if (vfs == NULL)
 743         return -1;
 744
 745     result = vfs->lseek ? (*vfs->lseek) (vfs_class_data_find_by_handle (fd), offset, whence) : -1;
 746     if (result == -1)
 747         errno = vfs->lseek ? vfs_ferrno (vfs) : E_NOTSUPP;
 748     return result;
 749 }
 750
 751 /* --------------------------------------------------------------------------------------------- */
 752 /* Following code heavily borrows from libiberty, mkstemps.c */
 753 /*
 754  * Arguments:
 755  * pname (output) - pointer to the name of the temp file (needs g_free).
 756  *                  NULL if the function fails.
 757  * prefix - part of the filename before the random part.
 758  *          Prepend $TMPDIR or /tmp if there are no path separators.
 759  * suffix - if not NULL, part of the filename after the random part.
 760  *
 761  * Result:
 762  * handle of the open file or -1 if couldn't open any.
 763  */
 764
 765 int
 766 mc_mkstemps (char **pname, const char *prefix, const char *suffix)
 767 {
 768     static const char letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 769     static unsigned long value;
 770     struct timeval tv;
 771     char *tmpbase;
 772     char *tmpname;
 773     char *XXXXXX;
 774     int count;
 775
 776     if (strchr (prefix, PATH_SEP) == NULL)
 777     {
 778         /* Add prefix first to find the position of XXXXXX */
 779         tmpbase = g_build_filename (mc_tmpdir (), prefix, NULL);
 780     }
 781     else
 782     {
 783         tmpbase = g_strdup (prefix);
 784     }
 785
 786     tmpname = g_strconcat (tmpbase, "XXXXXX", suffix, (char *) NULL);
 787     *pname = tmpname;
 788     XXXXXX = &tmpname[strlen (tmpbase)];
 789     g_free (tmpbase);
 790
 791     /* Get some more or less random data.  */
 792     gettimeofday (&tv, NULL);
 793     value += (tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
 794
 795     for (count = 0; count < TMP_MAX; ++count)
 796     {
 797         unsigned long v = value;
 798         int fd;
 799
 800         /* Fill in the random bits.  */
 801         XXXXXX[0] = letters[v % 62];
 802         v /= 62;
 803         XXXXXX[1] = letters[v % 62];
 804         v /= 62;
 805         XXXXXX[2] = letters[v % 62];
 806         v /= 62;
 807         XXXXXX[3] = letters[v % 62];
 808         v /= 62;
 809         XXXXXX[4] = letters[v % 62];
 810         v /= 62;
 811         XXXXXX[5] = letters[v % 62];
 812
 813         fd = open (tmpname, O_RDWR | O_CREAT | O_TRUNC | O_EXCL, S_IRUSR | S_IWUSR);
 814         if (fd >= 0)
 815         {
 816             /* Successfully created.  */
 817             return fd;
 818         }
 819
 820         /* This is a random value.  It is only necessary that the next
 821            TMP_MAX values generated by adding 7777 to VALUE are different
 822            with (module 2^32).  */
 823         value += 7777;
 824     }
 825
 826     /* Unsuccessful. Free the filename. */
 827     g_free (tmpname);
 828     *pname = NULL;
 829
 830     return -1;
 831 }
 832
 833 /* --------------------------------------------------------------------------------------------- */
 834 /**
 835  * Return the directory where mc should keep its temporary files.
 836  * This directory is (in Bourne shell terms) "${TMPDIR=/tmp}/mc-$USER"
 837  * When called the first time, the directory is created if needed.
 838  * The first call should be done early, since we are using fprintf()
 839  * and not message() to report possible problems.
 840  */
 841
 842 const char *
 843 mc_tmpdir (void)
 844 {
 845     static char buffer[64];
 846     static const char *tmpdir = NULL;
 847     const char *sys_tmp;
 848     struct passwd *pwd;
 849     struct stat st;
 850     const char *error = NULL;
 851
 852     /* Check if already correctly initialized */
 853     if (tmpdir && lstat (tmpdir, &st) == 0 && S_ISDIR (st.st_mode) &&
 854         st.st_uid == getuid () && (st.st_mode & 0777) == 0700)
 855         return tmpdir;
 856
 857     sys_tmp = getenv ("TMPDIR");
 858     if (!sys_tmp || sys_tmp[0] != '/')
 859     {
 860         sys_tmp = TMPDIR_DEFAULT;
 861     }
 862
 863     pwd = getpwuid (getuid ());
 864
 865     if (pwd)
 866         g_snprintf (buffer, sizeof (buffer), "%s/mc-%s", sys_tmp, pwd->pw_name);
 867     else
 868         g_snprintf (buffer, sizeof (buffer), "%s/mc-%lu", sys_tmp, (unsigned long) getuid ());
 869
 870     canonicalize_pathname (buffer);
 871
 872     if (lstat (buffer, &st) == 0)
 873     {
 874         /* Sanity check for existing directory */
 875         if (!S_ISDIR (st.st_mode))
 876             error = _("%s is not a directory\n");
 877         else if (st.st_uid != getuid ())
 878             error = _("Directory %s is not owned by you\n");
 879         else if (((st.st_mode & 0777) != 0700) && (chmod (buffer, 0700) != 0))
 880             error = _("Cannot set correct permissions for directory %s\n");
 881     }
 882     else
 883     {
 884         /* Need to create directory */
 885         if (mkdir (buffer, S_IRWXU) != 0)
 886         {
 887             fprintf (stderr,
 888                      _("Cannot create temporary directory %s: %s\n"),
 889                      buffer, unix_error_string (errno));
 890             error = "";
 891         }
 892     }
 893
 894     if (error != NULL)
 895     {
 896         int test_fd;
 897         char *test_fn, *fallback_prefix;
 898         int fallback_ok = 0;
 899
 900         if (*error)
 901             fprintf (stderr, error, buffer);
 902
 903         /* Test if sys_tmp is suitable for temporary files */
 904         fallback_prefix = g_strdup_printf ("%s/mctest", sys_tmp);
 905         test_fd = mc_mkstemps (&test_fn, fallback_prefix, NULL);
 906         g_free (fallback_prefix);
 907         if (test_fd != -1)
 908         {
 909             close (test_fd);
 910             test_fd = open (test_fn, O_RDONLY);
 911             if (test_fd != -1)
 912             {
 913                 close (test_fd);
 914                 unlink (test_fn);
 915                 fallback_ok = 1;
 916             }
 917         }
 918
 919         if (fallback_ok)
 920         {
 921             fprintf (stderr, _("Temporary files will be created in %s\n"), sys_tmp);
 922             g_snprintf (buffer, sizeof (buffer), "%s", sys_tmp);
 923             error = NULL;
 924         }
 925         else
 926         {
 927             fprintf (stderr, _("Temporary files will not be created\n"));
 928             g_snprintf (buffer, sizeof (buffer), "%s", "/dev/null/");
 929         }
 930
 931         fprintf (stderr, "%s\n", _("Press any key to continue..."));
 932         getc (stdin);
 933     }
 934
 935     tmpdir = buffer;
 936
 937     if (!error)
 938         g_setenv ("MC_TMPDIR", tmpdir, TRUE);
 939
 940     return tmpdir;
 941 }
 942
 943 /* --------------------------------------------------------------------------------------------- */