lib/utilunix.c

   1 /*
   2    Various utilities - Unix variants
   3
   4    Copyright (C) 1994-2018
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Miguel de Icaza, 1994, 1995, 1996
   9    Janne Kukonlehto, 1994, 1995, 1996
  10    Dugan Porter, 1994, 1995, 1996
  11    Jakub Jelinek, 1994, 1995, 1996
  12    Mauricio Plaza, 1994, 1995, 1996
  13
  14    The mc_realpath routine is mostly from uClibc package, written
  15    by Rick Sladkey <jrs@world.std.com>
  16
  17    This file is part of the Midnight Commander.
  18
  19    The Midnight Commander is free software: you can redistribute it
  20    and/or modify it under the terms of the GNU General Public License as
  21    published by the Free Software Foundation, either version 3 of the License,
  22    or (at your option) any later version.
  23
  24    The Midnight Commander is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27    GNU General Public License for more details.
  28
  29    You should have received a copy of the GNU General Public License
  30    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  31  */
  32
  33 /** \file utilunix.c
  34  *  \brief Source: various utilities - Unix variant
  35  */
  36
  37 #include <config.h>
  38
  39 #include <ctype.h>
  40 #include <errno.h>
  41 #include <limits.h>
  42 #include <signal.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #ifdef HAVE_SYS_PARAM_H
  48 #include <sys/param.h>
  49 #endif
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #ifdef HAVE_SYS_SELECT_H
  53 #include <sys/select.h>
  54 #endif
  55 #include <sys/wait.h>
  56 #ifdef HAVE_SYS_IOCTL_H
  57 #include <sys/ioctl.h>
  58 #endif
  59 #ifdef HAVE_GET_PROCESS_STATS
  60 #include <sys/procstats.h>
  61 #endif
  62 #include <pwd.h>
  63 #include <grp.h>
  64
  65 #include "lib/global.h"
  66
  67 #include "lib/unixcompat.h"
  68 #include "lib/vfs/vfs.h"        /* VFS_ENCODING_PREFIX */
  69 #include "lib/strutil.h"        /* str_move() */
  70 #include "lib/util.h"
  71 #include "lib/widget.h"         /* message() */
  72 #include "lib/vfs/xdirentry.h"
  73
  74 #ifdef HAVE_CHARSET
  75 #include "lib/charsets.h"
  76 #endif
  77
  78 #include "utilunix.h"
  79
  80 /*** global variables ****************************************************************************/
  81
  82 struct sigaction startup_handler;
  83
  84 /*** file scope macro definitions ****************************************************************/
  85
  86 #define UID_CACHE_SIZE 200
  87 #define GID_CACHE_SIZE 30
  88
  89 /* Pipes are guaranteed to be able to hold at least 4096 bytes */
  90 /* More than that would be unportable */
  91 #define MAX_PIPE_SIZE 4096
  92
  93 /*** file scope type declarations ****************************************************************/
  94
  95 typedef struct
  96 {
  97     int index;
  98     char *string;
  99 } int_cache;
 100
 101 typedef enum
 102 {
 103     FORK_ERROR = -1,
 104     FORK_CHILD,
 105     FORK_PARENT,
 106 } my_fork_state_t;
 107
 108 typedef struct
 109 {
 110     struct sigaction intr;
 111     struct sigaction quit;
 112     struct sigaction stop;
 113 } my_system_sigactions_t;
 114
 115 /*** file scope variables ************************************************************************/
 116
 117 static int_cache uid_cache[UID_CACHE_SIZE];
 118 static int_cache gid_cache[GID_CACHE_SIZE];
 119
 120 static int error_pipe[2];       /* File descriptors of error pipe */
 121 static int old_error;           /* File descriptor of old standard error */
 122
 123 /*** file scope functions ************************************************************************/
 124 /* --------------------------------------------------------------------------------------------- */
 125
 126 static char *
 127 i_cache_match (int id, int_cache * cache, int size)
 128 {
 129     int i;
 130
 131     for (i = 0; i < size; i++)
 132         if (cache[i].index == id)
 133             return cache[i].string;
 134     return 0;
 135 }
 136
 137 /* --------------------------------------------------------------------------------------------- */
 138
 139 static void
 140 i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
 141 {
 142     g_free (cache[*last].string);
 143     cache[*last].string = g_strdup (text);
 144     cache[*last].index = id;
 145     *last = ((*last) + 1) % size;
 146 }
 147
 148 /* --------------------------------------------------------------------------------------------- */
 149
 150 static my_fork_state_t
 151 my_fork (void)
 152 {
 153     pid_t pid;
 154
 155     pid = fork ();
 156
 157     if (pid < 0)
 158     {
 159         fprintf (stderr, "\n\nfork () = -1\n");
 160         return FORK_ERROR;
 161     }
 162
 163     if (pid == 0)
 164         return FORK_CHILD;
 165
 166     while (TRUE)
 167     {
 168         int status = 0;
 169
 170         if (waitpid (pid, &status, 0) > 0)
 171             return WEXITSTATUS (status) == 0 ? FORK_PARENT : FORK_ERROR;
 172
 173         if (errno != EINTR)
 174             return FORK_ERROR;
 175     }
 176 }
 177
 178 /* --------------------------------------------------------------------------------------------- */
 179
 180 static void
 181 my_system__save_sigaction_handlers (my_system_sigactions_t * sigactions)
 182 {
 183     struct sigaction ignore;
 184
 185     memset (&ignore, 0, sizeof (ignore));
 186     ignore.sa_handler = SIG_IGN;
 187     sigemptyset (&ignore.sa_mask);
 188
 189     sigaction (SIGINT, &ignore, &sigactions->intr);
 190     sigaction (SIGQUIT, &ignore, &sigactions->quit);
 191
 192     /* Restore the original SIGTSTP handler, we don't want ncurses' */
 193     /* handler messing the screen after the SIGCONT */
 194     sigaction (SIGTSTP, &startup_handler, &sigactions->stop);
 195 }
 196
 197 /* --------------------------------------------------------------------------------------------- */
 198
 199 static void
 200 my_system__restore_sigaction_handlers (my_system_sigactions_t * sigactions)
 201 {
 202     sigaction (SIGINT, &sigactions->intr, NULL);
 203     sigaction (SIGQUIT, &sigactions->quit, NULL);
 204     sigaction (SIGTSTP, &sigactions->stop, NULL);
 205 }
 206
 207 /* --------------------------------------------------------------------------------------------- */
 208
 209 static GPtrArray *
 210 my_system_make_arg_array (int flags, const char *shell, char **execute_name)
 211 {
 212     GPtrArray *args_array;
 213
 214     args_array = g_ptr_array_new ();
 215
 216     if ((flags & EXECUTE_AS_SHELL) != 0)
 217     {
 218         g_ptr_array_add (args_array, (gpointer) shell);
 219         g_ptr_array_add (args_array, (gpointer) "-c");
 220         *execute_name = g_strdup (shell);
 221     }
 222     else
 223     {
 224         char *shell_token;
 225
 226         shell_token = shell != NULL ? strchr (shell, ' ') : NULL;
 227         if (shell_token == NULL)
 228             *execute_name = g_strdup (shell);
 229         else
 230             *execute_name = g_strndup (shell, (gsize) (shell_token - shell));
 231
 232         g_ptr_array_add (args_array, (gpointer) shell);
 233     }
 234     return args_array;
 235 }
 236
 237 /* --------------------------------------------------------------------------------------------- */
 238
 239 static void
 240 mc_pread_stream (mc_pipe_stream_t * ps, const fd_set * fds)
 241 {
 242     size_t buf_len;
 243     ssize_t read_len;
 244
 245     if (!FD_ISSET (ps->fd, fds))
 246     {
 247         ps->len = MC_PIPE_STREAM_UNREAD;
 248         return;
 249     }
 250
 251     buf_len = (size_t) ps->len;
 252
 253     if (buf_len >= MC_PIPE_BUFSIZE)
 254         buf_len = ps->null_term ? MC_PIPE_BUFSIZE - 1 : MC_PIPE_BUFSIZE;
 255
 256     do
 257     {
 258         read_len = read (ps->fd, ps->buf, buf_len);
 259     }
 260     while (read_len < 0 && errno == EINTR);
 261
 262     if (read_len < 0)
 263     {
 264         /* reading error */
 265         ps->len = MC_PIPE_ERROR_READ;
 266         ps->error = errno;
 267     }
 268     else if (read_len == 0)
 269         /* EOF */
 270         ps->len = MC_PIPE_STREAM_EOF;
 271     else
 272     {
 273         /* success */
 274         ps->len = read_len;
 275
 276         if (ps->null_term)
 277             ps->buf[(size_t) ps->len] = '\0';
 278     }
 279 }
 280
 281 /* --------------------------------------------------------------------------------------------- */
 282 /*** public functions ****************************************************************************/
 283 /* --------------------------------------------------------------------------------------------- */
 284
 285 const char *
 286 get_owner (uid_t uid)
 287 {
 288     struct passwd *pwd;
 289     char *name;
 290     static uid_t uid_last;
 291
 292     name = i_cache_match ((int) uid, uid_cache, UID_CACHE_SIZE);
 293     if (name != NULL)
 294         return name;
 295
 296     pwd = getpwuid (uid);
 297     if (pwd != NULL)
 298     {
 299         i_cache_add ((int) uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, (int *) &uid_last);
 300         return pwd->pw_name;
 301     }
 302     else
 303     {
 304         static char ibuf[10];
 305
 306         g_snprintf (ibuf, sizeof (ibuf), "%d", (int) uid);
 307         return ibuf;
 308     }
 309 }
 310
 311 /* --------------------------------------------------------------------------------------------- */
 312
 313 const char *
 314 get_group (gid_t gid)
 315 {
 316     struct group *grp;
 317     char *name;
 318     static gid_t gid_last;
 319
 320     name = i_cache_match ((int) gid, gid_cache, GID_CACHE_SIZE);
 321     if (name != NULL)
 322         return name;
 323
 324     grp = getgrgid (gid);
 325     if (grp != NULL)
 326     {
 327         i_cache_add ((int) gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, (int *) &gid_last);
 328         return grp->gr_name;
 329     }
 330     else
 331     {
 332         static char gbuf[10];
 333
 334         g_snprintf (gbuf, sizeof (gbuf), "%d", (int) gid);
 335         return gbuf;
 336     }
 337 }
 338
 339 /* --------------------------------------------------------------------------------------------- */
 340 /* Since ncurses uses a handler that automatically refreshes the */
 341 /* screen after a SIGCONT, and we don't want this behavior when */
 342 /* spawning a child, we save the original handler here */
 343
 344 void
 345 save_stop_handler (void)
 346 {
 347     sigaction (SIGTSTP, NULL, &startup_handler);
 348 }
 349
 350 /* --------------------------------------------------------------------------------------------- */
 351 /**
 352  * Wrapper for _exit() system call.
 353  * The _exit() function has gcc's attribute 'noreturn', and this is reason why we can't
 354  * mock the call.
 355  *
 356  * @param status exit code
 357  */
 358
 359 void
 360 /* __attribute__ ((noreturn)) */
 361 my_exit (int status)
 362 {
 363     _exit (status);
 364 }
 365
 366 /* --------------------------------------------------------------------------------------------- */
 367 /**
 368  * Call external programs.
 369  *
 370  * @parameter flags   addition conditions for running external programs.
 371  * @parameter shell   shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 372  *                    Shell (or command) will be found in paths described in PATH variable
 373  *                    (if shell parameter doesn't begin from path delimiter)
 374  * @parameter command Command for shell (or first parameter for command, if flags contain EXECUTE_AS_SHELL)
 375  * @return 0 if successfull, -1 otherwise
 376  */
 377
 378 int
 379 my_system (int flags, const char *shell, const char *command)
 380 {
 381     return my_systeml (flags, shell, command, NULL);
 382 }
 383
 384 /* --------------------------------------------------------------------------------------------- */
 385 /**
 386  * Call external programs with various parameters number.
 387  *
 388  * @parameter flags addition conditions for running external programs.
 389  * @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 390  *                  Shell (or command) will be found in pathes described in PATH variable
 391  *                  (if shell parameter doesn't begin from path delimiter)
 392  * @parameter ...   Command for shell with addition parameters for shell
 393  *                  (or parameters for command, if flags contain EXECUTE_AS_SHELL).
 394  *                  Should be NULL terminated.
 395  * @return 0 if successfull, -1 otherwise
 396  */
 397
 398
 399 int
 400 my_systeml (int flags, const char *shell, ...)
 401 {
 402     GPtrArray *args_array;
 403     int status = 0;
 404     va_list vargs;
 405     char *one_arg;
 406
 407     args_array = g_ptr_array_new ();
 408
 409     va_start (vargs, shell);
 410     while ((one_arg = va_arg (vargs, char *)) != NULL)
 411           g_ptr_array_add (args_array, one_arg);
 412     va_end (vargs);
 413
 414     g_ptr_array_add (args_array, NULL);
 415     status = my_systemv_flags (flags, shell, (char *const *) args_array->pdata);
 416
 417     g_ptr_array_free (args_array, TRUE);
 418
 419     return status;
 420 }
 421
 422 /* --------------------------------------------------------------------------------------------- */
 423 /**
 424  * Call external programs with array of strings as parameters.
 425  *
 426  * @parameter command command to run. Command will be found in paths described in PATH variable
 427  *                    (if command parameter doesn't begin from path delimiter)
 428  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 429  * @return 0 if successfull, -1 otherwise
 430  */
 431
 432 int
 433 my_systemv (const char *command, char *const argv[])
 434 {
 435     my_fork_state_t fork_state;
 436     int status = 0;
 437     my_system_sigactions_t sigactions;
 438
 439     my_system__save_sigaction_handlers (&sigactions);
 440
 441     fork_state = my_fork ();
 442     switch (fork_state)
 443     {
 444     case FORK_ERROR:
 445         status = -1;
 446         break;
 447     case FORK_CHILD:
 448         {
 449             signal (SIGINT, SIG_DFL);
 450             signal (SIGQUIT, SIG_DFL);
 451             signal (SIGTSTP, SIG_DFL);
 452             signal (SIGCHLD, SIG_DFL);
 453
 454             execvp (command, argv);
 455             my_exit (127);      /* Exec error */
 456         }
 457         MC_FALLTHROUGH;
 458         /* no break here, or unreachable-code warning by no returning my_exit() */
 459     default:
 460         status = 0;
 461         break;
 462     }
 463     my_system__restore_sigaction_handlers (&sigactions);
 464
 465     return status;
 466 }
 467
 468 /* --------------------------------------------------------------------------------------------- */
 469 /**
 470  * Call external programs with flags and with array of strings as parameters.
 471  *
 472  * @parameter flags   addition conditions for running external programs.
 473  * @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 474  *                    Shell (or command) will be found in paths described in PATH variable
 475  *                    (if shell parameter doesn't begin from path delimiter)
 476  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 477  * @return 0 if successfull, -1 otherwise
 478  */
 479
 480 int
 481 my_systemv_flags (int flags, const char *command, char *const argv[])
 482 {
 483     char *execute_name = NULL;
 484     GPtrArray *args_array;
 485     int status = 0;
 486
 487     args_array = my_system_make_arg_array (flags, command, &execute_name);
 488
 489     for (; argv != NULL && *argv != NULL; argv++)
 490         g_ptr_array_add (args_array, *argv);
 491
 492     g_ptr_array_add (args_array, NULL);
 493     status = my_systemv (execute_name, (char *const *) args_array->pdata);
 494
 495     g_free (execute_name);
 496     g_ptr_array_free (args_array, TRUE);
 497
 498     return status;
 499 }
 500
 501 /* --------------------------------------------------------------------------------------------- */
 502 /**
 503  * Create pipe and run child process.
 504  *
 505  * @parameter command command line of child process
 506  * @paremeter error contains pointer to object to handle error code and message
 507  *
 508  * @return newly created object of mc_pipe_t class in success, NULL otherwise
 509  */
 510
 511 mc_pipe_t *
 512 mc_popen (const char *command, GError ** error)
 513 {
 514     mc_pipe_t *p;
 515     const char *const argv[] = { "/bin/sh", "sh", "-c", command, NULL };
 516
 517     p = g_try_new (mc_pipe_t, 1);
 518     if (p == NULL)
 519     {
 520         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE, "%s",
 521                           _("Cannot create pipe descriptor"));
 522         goto ret_err;
 523     }
 524
 525     if (!g_spawn_async_with_pipes
 526         (NULL, (gchar **) argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_FILE_AND_ARGV_ZERO,
 527          NULL, NULL, &p->child_pid, NULL, &p->out.fd, &p->err.fd, error))
 528     {
 529         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE_STREAM, "%s",
 530                           _("Cannot create pipe streams"));
 531         goto ret_err;
 532     }
 533
 534     p->out.buf[0] = '\0';
 535     p->out.len = MC_PIPE_BUFSIZE;
 536     p->out.null_term = FALSE;
 537
 538     p->err.buf[0] = '\0';
 539     p->err.len = MC_PIPE_BUFSIZE;
 540     p->err.null_term = FALSE;
 541
 542     return p;
 543
 544   ret_err:
 545     g_free (p);
 546     return NULL;
 547 }
 548
 549 /* --------------------------------------------------------------------------------------------- */
 550 /**
 551  * Read stdout and stderr of pipe asynchronously.
 552  *
 553  * @parameter p pipe descriptor
 554  *
 555  * The lengths of read data contain in p->out.len and p->err.len.
 556  * Before read, p->xxx.len is an input:
 557  *   p->xxx.len > 0:  do read stream p->xxx and store data in p->xxx.buf;
 558  *   p->xxx.len <= 0: do not read stream p->xxx.
 559  *
 560  * After read, p->xxx.len is an output and contains the following:
 561  *   p->xxx.len > 0: an actual length of read data stored in p->xxx.buf;
 562  *   p->xxx.len == MC_PIPE_STREAM_EOF: EOF of stream p->xxx;
 563  *   p->xxx.len == MC_PIPE_STREAM_UNREAD: stream p->xxx was not read;
 564  *   p->xxx.len == MC_PIPE_ERROR_READ: reading error, and p->xxx.errno is set appropriately.
 565  *
 566  * @paremeter error contains pointer to object to handle error code and message
 567  */
 568
 569 void
 570 mc_pread (mc_pipe_t * p, GError ** error)
 571 {
 572     gboolean read_out, read_err;
 573     fd_set fds;
 574     int maxfd = 0;
 575     int res;
 576
 577     if (error != NULL)
 578         *error = NULL;
 579
 580     read_out = p->out.fd >= 0 && p->out.len > 0;
 581     read_err = p->err.fd >= 0 && p->err.len > 0;
 582
 583     if (!read_out && !read_err)
 584     {
 585         p->out.len = MC_PIPE_STREAM_UNREAD;
 586         p->err.len = MC_PIPE_STREAM_UNREAD;
 587         return;
 588     }
 589
 590     FD_ZERO (&fds);
 591     if (read_out)
 592     {
 593         FD_SET (p->out.fd, &fds);
 594         maxfd = p->out.fd;
 595     }
 596
 597     if (read_err)
 598     {
 599         FD_SET (p->err.fd, &fds);
 600         maxfd = MAX (maxfd, p->err.fd);
 601     }
 602
 603     /* no timeout */
 604     res = select (maxfd + 1, &fds, NULL, NULL, NULL);
 605     if (res < 0 && errno != EINTR)
 606     {
 607         mc_propagate_error (error, MC_PIPE_ERROR_READ,
 608                             _
 609                             ("Unexpected error in select() reading data from a child process:\n%s"),
 610                             unix_error_string (errno));
 611         return;
 612     }
 613
 614     if (read_out)
 615         mc_pread_stream (&p->out, &fds);
 616     else
 617         p->out.len = MC_PIPE_STREAM_UNREAD;
 618
 619     if (read_err)
 620         mc_pread_stream (&p->err, &fds);
 621     else
 622         p->err.len = MC_PIPE_STREAM_UNREAD;
 623 }
 624
 625 /* --------------------------------------------------------------------------------------------- */
 626 /**
 627  * Close pipe and destroy pipe descriptor.
 628  *
 629  * @paremeter p pipe descriptor
 630  * @paremeter error contains pointer to object to handle error code and message
 631  */
 632
 633 void
 634 mc_pclose (mc_pipe_t * p, GError ** error)
 635 {
 636     int res;
 637
 638     if (p->out.fd >= 0)
 639         res = close (p->out.fd);
 640     if (p->err.fd >= 0)
 641         res = close (p->err.fd);
 642
 643     do
 644     {
 645         int status;
 646
 647         res = waitpid (p->child_pid, &status, 0);
 648     }
 649     while (res < 0 && errno == EINTR);
 650
 651     if (res < 0)
 652         mc_replace_error (error, MC_PIPE_ERROR_READ, _("Unexpected error in waitpid():\n%s"),
 653                           unix_error_string (errno));
 654
 655     g_free (p);
 656 }
 657
 658 /* --------------------------------------------------------------------------------------------- */
 659
 660 /**
 661  * Perform tilde expansion if possible.
 662  *
 663  * @param directory pointer to the path
 664  *
 665  * @return newly allocated string, even if it's unchanged.
 666  */
 667
 668 char *
 669 tilde_expand (const char *directory)
 670 {
 671     struct passwd *passwd;
 672     const char *p, *q;
 673
 674     if (*directory != '~')
 675         return g_strdup (directory);
 676
 677     p = directory + 1;
 678
 679     /* d = "~" or d = "~/" */
 680     if (*p == '\0' || IS_PATH_SEP (*p))
 681     {
 682         passwd = getpwuid (geteuid ());
 683         q = IS_PATH_SEP (*p) ? p + 1 : "";
 684     }
 685     else
 686     {
 687         q = strchr (p, PATH_SEP);
 688         if (!q)
 689         {
 690             passwd = getpwnam (p);
 691         }
 692         else
 693         {
 694             char *name;
 695
 696             name = g_strndup (p, q - p);
 697             passwd = getpwnam (name);
 698             q++;
 699             g_free (name);
 700         }
 701     }
 702
 703     /* If we can't figure the user name, leave tilde unexpanded */
 704     if (!passwd)
 705         return g_strdup (directory);
 706
 707     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 708 }
 709
 710 /* --------------------------------------------------------------------------------------------- */
 711 /**
 712  * Creates a pipe to hold standard error for a later analysis.
 713  * The pipe can hold 4096 bytes. Make sure no more is written
 714  * or a deadlock might occur.
 715  */
 716
 717 void
 718 open_error_pipe (void)
 719 {
 720     if (pipe (error_pipe) < 0)
 721     {
 722         message (D_NORMAL, _("Warning"), _("Pipe failed"));
 723     }
 724     old_error = dup (STDERR_FILENO);
 725     if (old_error < 0 || close (STDERR_FILENO) != 0 || dup (error_pipe[1]) != STDERR_FILENO)
 726     {
 727         message (D_NORMAL, _("Warning"), _("Dup failed"));
 728
 729         close (error_pipe[0]);
 730         error_pipe[0] = -1;
 731     }
 732     else
 733     {
 734         /*
 735          * Settng stderr in nonblocking mode as we close it earlier, than
 736          * program stops. We try to read some error at program startup,
 737          * but we should not block on it.
 738          *
 739          * TODO: make piped stdin/stderr poll()/select()able to get rid
 740          * of following hack.
 741          */
 742         int fd_flags;
 743         fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
 744         if (fd_flags != -1)
 745         {
 746             fd_flags |= O_NONBLOCK;
 747             if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
 748             {
 749                 /* TODO: handle it somehow */
 750             }
 751         }
 752     }
 753     /* we never write there */
 754     close (error_pipe[1]);
 755     error_pipe[1] = -1;
 756 }
 757
 758 /* --------------------------------------------------------------------------------------------- */
 759 /**
 760  * Close a pipe
 761  *
 762  * @param error '-1' - ignore errors, '0' - display warning, '1' - display error
 763  * @param text is prepended to the error message from the pipe
 764  *
 765  * @return not 0 if an error was displayed
 766  */
 767
 768 int
 769 close_error_pipe (int error, const char *text)
 770 {
 771     const char *title;
 772     char msg[MAX_PIPE_SIZE];
 773     int len = 0;
 774
 775     /* already closed */
 776     if (error_pipe[0] == -1)
 777         return 0;
 778
 779     if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
 780         title = MSG_ERROR;
 781     else
 782         title = _("Warning");
 783     if (old_error >= 0)
 784     {
 785         if (dup2 (old_error, STDERR_FILENO) == -1)
 786         {
 787             if (error < 0)
 788                 error = D_ERROR;
 789
 790             message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
 791             return 1;
 792         }
 793         close (old_error);
 794         len = read (error_pipe[0], msg, sizeof (msg) - 1);
 795
 796         if (len >= 0)
 797             msg[len] = 0;
 798         close (error_pipe[0]);
 799         error_pipe[0] = -1;
 800     }
 801     if (error < 0)
 802         return 0;               /* Just ignore error message */
 803     if (text == NULL)
 804     {
 805         if (len <= 0)
 806             return 0;           /* Nothing to show */
 807
 808         /* Show message from pipe */
 809         message (error, title, "%s", msg);
 810     }
 811     else
 812     {
 813         /* Show given text and possible message from pipe */
 814         message (error, title, "%s\n%s", text, msg);
 815     }
 816     return 1;
 817 }
 818
 819 /* --------------------------------------------------------------------------------------------- */
 820 /**
 821  * Canonicalize path, and return a new path.  Do everything in place.
 822  * The new path differs from path in:
 823  *      Multiple '/'s are collapsed to a single '/'.
 824  *      Leading './'s and trailing '/.'s are removed.
 825  *      Trailing '/'s are removed.
 826  *      Non-leading '../'s and trailing '..'s are handled by removing
 827  *      portions of the path.
 828  * Well formed UNC paths are modified only in the local part.
 829  */
 830
 831 void
 832 custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 833 {
 834     char *p, *s;
 835     char *lpath = path;         /* path without leading UNC part */
 836     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 837
 838     /* Detect and preserve UNC paths: //server/... */
 839     if ((flags & CANON_PATH_GUARDUNC) != 0 && IS_PATH_SEP (path[0]) && IS_PATH_SEP (path[1]))
 840     {
 841         p = path + 2;
 842         while (p[0] != '\0' && !IS_PATH_SEP (p[0]))
 843             p++;
 844         if (IS_PATH_SEP (p[0]) && p > path + 2)
 845             lpath = p;
 846     }
 847
 848     if (!lpath[0] || !lpath[1])
 849         return;
 850
 851     if (flags & CANON_PATH_JOINSLASHES)
 852     {
 853         /* Collapse multiple slashes */
 854         p = lpath;
 855         while (*p)
 856         {
 857             if (IS_PATH_SEP (p[0]) && IS_PATH_SEP (p[1]) && (p == lpath || *(p - 1) != ':'))
 858             {
 859                 s = p + 1;
 860                 while (IS_PATH_SEP (*(++s)))
 861                     ;
 862                 str_move (p + 1, s);
 863             }
 864             p++;
 865         }
 866     }
 867
 868     if (flags & CANON_PATH_JOINSLASHES)
 869     {
 870         /* Collapse "/./" -> "/" */
 871         p = lpath;
 872         while (*p)
 873         {
 874             if (IS_PATH_SEP (p[0]) && p[1] == '.' && IS_PATH_SEP (p[2]))
 875                 str_move (p, p + 2);
 876             else
 877                 p++;
 878         }
 879     }
 880
 881     if (flags & CANON_PATH_REMSLASHDOTS)
 882     {
 883         size_t len;
 884
 885         /* Remove trailing slashes */
 886         p = lpath + strlen (lpath) - 1;
 887         while (p > lpath && IS_PATH_SEP (*p))
 888         {
 889             if (p >= lpath + url_delim_len - 1
 890                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 891                 break;
 892             *p-- = 0;
 893         }
 894
 895         /* Remove leading "./" */
 896         if (lpath[0] == '.' && IS_PATH_SEP (lpath[1]))
 897         {
 898             if (lpath[2] == 0)
 899             {
 900                 lpath[1] = 0;
 901                 return;
 902             }
 903             else
 904             {
 905                 str_move (lpath, lpath + 2);
 906             }
 907         }
 908
 909         /* Remove trailing "/" or "/." */
 910         len = strlen (lpath);
 911         if (len < 2)
 912             return;
 913         if (IS_PATH_SEP (lpath[len - 1])
 914             && (len < url_delim_len
 915                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 916                             url_delim_len) != 0))
 917         {
 918             lpath[len - 1] = '\0';
 919         }
 920         else
 921         {
 922             if (lpath[len - 1] == '.' && IS_PATH_SEP (lpath[len - 2]))
 923             {
 924                 if (len == 2)
 925                 {
 926                     lpath[1] = '\0';
 927                     return;
 928                 }
 929                 else
 930                 {
 931                     lpath[len - 2] = '\0';
 932                 }
 933             }
 934         }
 935     }
 936
 937     if (flags & CANON_PATH_REMDOUBLEDOTS)
 938     {
 939 #ifdef HAVE_CHARSET
 940         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 941 #endif /* HAVE_CHARSET */
 942
 943         /* Collapse "/.." with the previous part of path */
 944         p = lpath;
 945         while (p[0] && p[1] && p[2])
 946         {
 947             if (!IS_PATH_SEP (p[0]) || p[1] != '.' || p[2] != '.'
 948                 || (!IS_PATH_SEP (p[3]) && p[3] != '\0'))
 949             {
 950                 p++;
 951                 continue;
 952             }
 953
 954             /* search for the previous token */
 955             s = p - 1;
 956             if (s >= lpath + url_delim_len - 2
 957                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 958             {
 959                 s -= (url_delim_len - 2);
 960                 while (s >= lpath && !IS_PATH_SEP (*s--))
 961                     ;
 962             }
 963
 964             while (s >= lpath)
 965             {
 966                 if (s - url_delim_len > lpath
 967                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 968                 {
 969                     char *vfs_prefix = s - url_delim_len;
 970                     vfs_class *vclass;
 971
 972                     while (vfs_prefix > lpath && !IS_PATH_SEP (*--vfs_prefix))
 973                         ;
 974                     if (IS_PATH_SEP (*vfs_prefix))
 975                         vfs_prefix++;
 976                     *(s - url_delim_len) = '\0';
 977
 978                     vclass = vfs_prefix_to_class (vfs_prefix);
 979                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 980
 981                     if (vclass != NULL)
 982                     {
 983                         struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
 984                         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 985                         {
 986                             s = vfs_prefix;
 987                             continue;
 988                         }
 989                     }
 990                 }
 991
 992                 if (IS_PATH_SEP (*s))
 993                     break;
 994
 995                 s--;
 996             }
 997
 998             s++;
 999
1000             /* If the previous token is "..", we cannot collapse it */
1001             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
1002             {
1003                 p += 3;
1004                 continue;
1005             }
1006
1007             if (p[3] != 0)
1008             {
1009                 if (s == lpath && IS_PATH_SEP (*s))
1010                 {
1011                     /* "/../foo" -> "/foo" */
1012                     str_move (s + 1, p + 4);
1013                 }
1014                 else
1015                 {
1016                     /* "token/../foo" -> "foo" */
1017 #ifdef HAVE_CHARSET
1018                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
1019                         && (is_supported_encoding (s + enc_prefix_len)))
1020                         /* special case: remove encoding */
1021                         str_move (s, p + 1);
1022                     else
1023 #endif /* HAVE_CHARSET */
1024                         str_move (s, p + 4);
1025                 }
1026                 p = (s > lpath) ? s - 1 : s;
1027                 continue;
1028             }
1029
1030             /* trailing ".." */
1031             if (s == lpath)
1032             {
1033                 /* "token/.." -> "." */
1034                 if (!IS_PATH_SEP (lpath[0]))
1035                     lpath[0] = '.';
1036                 lpath[1] = '\0';
1037             }
1038             else
1039             {
1040                 /* "foo/token/.." -> "foo" */
1041                 if (s == lpath + 1)
1042                     s[0] = '\0';
1043 #ifdef HAVE_CHARSET
1044                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
1045                          && (is_supported_encoding (s + enc_prefix_len)))
1046                 {
1047                     /* special case: remove encoding */
1048                     s[0] = '.';
1049                     s[1] = '.';
1050                     s[2] = '\0';
1051
1052                     /* search for the previous token */
1053                     /* IS_PATH_SEP (s[-1]) */
1054                     p = s - 1;
1055                     while (p >= lpath && !IS_PATH_SEP (*p))
1056                         p--;
1057
1058                     if (p >= lpath)
1059                         continue;
1060                 }
1061 #endif /* HAVE_CHARSET */
1062                 else
1063                 {
1064                     if (s >= lpath + url_delim_len
1065                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
1066                         *s = '\0';
1067                     else
1068                         s[-1] = '\0';
1069                 }
1070             }
1071
1072             break;
1073         }
1074     }
1075 }
1076
1077 /* --------------------------------------------------------------------------------------------- */
1078
1079 void
1080 canonicalize_pathname (char *path)
1081 {
1082     custom_canonicalize_pathname (path, CANON_PATH_ALL);
1083 }
1084
1085 /* --------------------------------------------------------------------------------------------- */
1086
1087 #ifdef HAVE_GET_PROCESS_STATS
1088 int
1089 gettimeofday (struct timeval *tp, void *tzp)
1090 {
1091     return get_process_stats (tp, PS_SELF, 0, 0);
1092 }
1093 #endif /* HAVE_GET_PROCESS_STATS */
1094
1095 /* --------------------------------------------------------------------------------------------- */
1096
1097 char *
1098 mc_realpath (const char *path, char *resolved_path)
1099 {
1100 #ifdef HAVE_CHARSET
1101     const char *p = path;
1102     gboolean absolute_path = FALSE;
1103
1104     if (IS_PATH_SEP (*p))
1105     {
1106         absolute_path = TRUE;
1107         p++;
1108     }
1109
1110     /* ignore encoding: skip "#enc:" */
1111     if (g_str_has_prefix (p, VFS_ENCODING_PREFIX))
1112     {
1113         p += strlen (VFS_ENCODING_PREFIX);
1114         p = strchr (p, PATH_SEP);
1115         if (p != NULL)
1116         {
1117             if (!absolute_path && p[1] != '\0')
1118                 p++;
1119
1120             path = p;
1121         }
1122     }
1123 #endif /* HAVE_CHARSET */
1124
1125 #ifdef HAVE_REALPATH
1126     return realpath (path, resolved_path);
1127 #else
1128     {
1129         char copy_path[PATH_MAX];
1130         char got_path[PATH_MAX];
1131         char *new_path = got_path;
1132         char *max_path;
1133 #ifdef S_IFLNK
1134         char link_path[PATH_MAX];
1135         int readlinks = 0;
1136         int n;
1137 #endif /* S_IFLNK */
1138
1139         /* Make a copy of the source path since we may need to modify it. */
1140         if (strlen (path) >= PATH_MAX - 2)
1141         {
1142             errno = ENAMETOOLONG;
1143             return NULL;
1144         }
1145         strcpy (copy_path, path);
1146         path = copy_path;
1147         max_path = copy_path + PATH_MAX - 2;
1148         /* If it's a relative pathname use getwd for starters. */
1149         if (!IS_PATH_SEP (*path))
1150         {
1151             new_path = g_get_current_dir ();
1152             if (new_path == NULL)
1153             {
1154                 strcpy (got_path, "");
1155             }
1156             else
1157             {
1158                 g_snprintf (got_path, sizeof (got_path), "%s", new_path);
1159                 g_free (new_path);
1160                 new_path = got_path;
1161             }
1162
1163             new_path += strlen (got_path);
1164             if (!IS_PATH_SEP (new_path[-1]))
1165                 *new_path++ = PATH_SEP;
1166         }
1167         else
1168         {
1169             *new_path++ = PATH_SEP;
1170             path++;
1171         }
1172         /* Expand each slash-separated pathname component. */
1173         while (*path != '\0')
1174         {
1175             /* Ignore stray "/". */
1176             if (IS_PATH_SEP (*path))
1177             {
1178                 path++;
1179                 continue;
1180             }
1181             if (*path == '.')
1182             {
1183                 /* Ignore ".". */
1184                 if (path[1] == '\0' || IS_PATH_SEP (path[1]))
1185                 {
1186                     path++;
1187                     continue;
1188                 }
1189                 if (path[1] == '.')
1190                 {
1191                     if (path[2] == '\0' || IS_PATH_SEP (path[2]))
1192                     {
1193                         path += 2;
1194                         /* Ignore ".." at root. */
1195                         if (new_path == got_path + 1)
1196                             continue;
1197                         /* Handle ".." by backing up. */
1198                         while (!IS_PATH_SEP ((--new_path)[-1]))
1199                             ;
1200                         continue;
1201                     }
1202                 }
1203             }
1204             /* Safely copy the next pathname component. */
1205             while (*path != '\0' && !IS_PATH_SEP (*path))
1206             {
1207                 if (path > max_path)
1208                 {
1209                     errno = ENAMETOOLONG;
1210                     return NULL;
1211                 }
1212                 *new_path++ = *path++;
1213             }
1214 #ifdef S_IFLNK
1215             /* Protect against infinite loops. */
1216             if (readlinks++ > MAXSYMLINKS)
1217             {
1218                 errno = ELOOP;
1219                 return NULL;
1220             }
1221             /* See if latest pathname component is a symlink. */
1222             *new_path = '\0';
1223             n = readlink (got_path, link_path, PATH_MAX - 1);
1224             if (n < 0)
1225             {
1226                 /* EINVAL means the file exists but isn't a symlink. */
1227                 if (errno != EINVAL)
1228                 {
1229                     /* Make sure it's null terminated. */
1230                     *new_path = '\0';
1231                     strcpy (resolved_path, got_path);
1232                     return NULL;
1233                 }
1234             }
1235             else
1236             {
1237                 /* Note: readlink doesn't add the null byte. */
1238                 link_path[n] = '\0';
1239                 if (IS_PATH_SEP (*link_path))
1240                     /* Start over for an absolute symlink. */
1241                     new_path = got_path;
1242                 else
1243                     /* Otherwise back up over this component. */
1244                     while (!IS_PATH_SEP (*(--new_path)))
1245                         ;
1246                 /* Safe sex check. */
1247                 if (strlen (path) + n >= PATH_MAX - 2)
1248                 {
1249                     errno = ENAMETOOLONG;
1250                     return NULL;
1251                 }
1252                 /* Insert symlink contents into path. */
1253                 strcat (link_path, path);
1254                 strcpy (copy_path, link_path);
1255                 path = copy_path;
1256             }
1257 #endif /* S_IFLNK */
1258             *new_path++ = PATH_SEP;
1259         }
1260         /* Delete trailing slash but don't whomp a lone slash. */
1261         if (new_path != got_path + 1 && IS_PATH_SEP (new_path[-1]))
1262             new_path--;
1263         /* Make sure it's null terminated. */
1264         *new_path = '\0';
1265         strcpy (resolved_path, got_path);
1266         return resolved_path;
1267     }
1268 #endif /* HAVE_REALPATH */
1269 }
1270
1271 /* --------------------------------------------------------------------------------------------- */
1272 /**
1273  * Return the index of the permissions triplet
1274  *
1275  */
1276
1277 int
1278 get_user_permissions (struct stat *st)
1279 {
1280     static gboolean initialized = FALSE;
1281     static gid_t *groups;
1282     static int ngroups;
1283     static uid_t uid;
1284     int i;
1285
1286     if (!initialized)
1287     {
1288         uid = geteuid ();
1289
1290         ngroups = getgroups (0, NULL);
1291         if (ngroups == -1)
1292             ngroups = 0;        /* ignore errors */
1293
1294         /* allocate space for one element in addition to what
1295          * will be filled by getgroups(). */
1296         groups = g_new (gid_t, ngroups + 1);
1297
1298         if (ngroups != 0)
1299         {
1300             ngroups = getgroups (ngroups, groups);
1301             if (ngroups == -1)
1302                 ngroups = 0;    /* ignore errors */
1303         }
1304
1305         /* getgroups() may or may not return the effective group ID,
1306          * so we always include it at the end of the list. */
1307         groups[ngroups++] = getegid ();
1308
1309         initialized = TRUE;
1310     }
1311
1312     if (st->st_uid == uid || uid == 0)
1313         return 0;
1314
1315     for (i = 0; i < ngroups; i++)
1316     {
1317         if (st->st_gid == groups[i])
1318             return 1;
1319     }
1320
1321     return 2;
1322 }
1323
1324 /* --------------------------------------------------------------------------------------------- */
1325 /**
1326  * Build filename from arguments.
1327  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1328  */
1329
1330 char *
1331 mc_build_filenamev (const char *first_element, va_list args)
1332 {
1333     gboolean absolute;
1334     const char *element = first_element;
1335     GString *path;
1336     char *ret;
1337
1338     if (element == NULL)
1339         return NULL;
1340
1341     path = g_string_new ("");
1342
1343     absolute = IS_PATH_SEP (*first_element);
1344
1345     do
1346     {
1347         if (*element == '\0')
1348             element = va_arg (args, char *);
1349         else
1350         {
1351             char *tmp_element;
1352             size_t len;
1353             const char *start;
1354
1355             tmp_element = g_strdup (element);
1356
1357             element = va_arg (args, char *);
1358
1359             canonicalize_pathname (tmp_element);
1360             len = strlen (tmp_element);
1361             start = IS_PATH_SEP (tmp_element[0]) ? tmp_element + 1 : tmp_element;
1362
1363             g_string_append (path, start);
1364             if (!IS_PATH_SEP (tmp_element[len - 1]) && element != NULL)
1365                 g_string_append_c (path, PATH_SEP);
1366
1367             g_free (tmp_element);
1368         }
1369     }
1370     while (element != NULL);
1371
1372     if (absolute)
1373         g_string_prepend_c (path, PATH_SEP);
1374
1375     ret = g_string_free (path, FALSE);
1376     canonicalize_pathname (ret);
1377
1378     return ret;
1379 }
1380
1381 /* --------------------------------------------------------------------------------------------- */
1382 /**
1383  * Build filename from arguments.
1384  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1385  */
1386
1387 char *
1388 mc_build_filename (const char *first_element, ...)
1389 {
1390     va_list args;
1391     char *ret;
1392
1393     if (first_element == NULL)
1394         return NULL;
1395
1396     va_start (args, first_element);
1397     ret = mc_build_filenamev (first_element, args);
1398     va_end (args);
1399     return ret;
1400 }
1401
1402 /* --------------------------------------------------------------------------------------------- */