lib/utilunix.c

   1 /*
   2    Various utilities - Unix variants
   3
   4    Copyright (C) 1994-2017
   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         /* no break here, or unreachable-code warning by no returning my_exit() */
 458     default:
 459         status = 0;
 460         break;
 461     }
 462     my_system__restore_sigaction_handlers (&sigactions);
 463
 464     return status;
 465 }
 466
 467 /* --------------------------------------------------------------------------------------------- */
 468 /**
 469  * Call external programs with flags and with array of strings as parameters.
 470  *
 471  * @parameter flags   addition conditions for running external programs.
 472  * @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 473  *                    Shell (or command) will be found in paths described in PATH variable
 474  *                    (if shell parameter doesn't begin from path delimiter)
 475  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 476  * @return 0 if successfull, -1 otherwise
 477  */
 478
 479 int
 480 my_systemv_flags (int flags, const char *command, char *const argv[])
 481 {
 482     char *execute_name = NULL;
 483     GPtrArray *args_array;
 484     int status = 0;
 485
 486     args_array = my_system_make_arg_array (flags, command, &execute_name);
 487
 488     for (; argv != NULL && *argv != NULL; argv++)
 489         g_ptr_array_add (args_array, *argv);
 490
 491     g_ptr_array_add (args_array, NULL);
 492     status = my_systemv (execute_name, (char *const *) args_array->pdata);
 493
 494     g_free (execute_name);
 495     g_ptr_array_free (args_array, TRUE);
 496
 497     return status;
 498 }
 499
 500 /* --------------------------------------------------------------------------------------------- */
 501 /**
 502  * Create pipe and run child process.
 503  *
 504  * @parameter command command line of child process
 505  * @paremeter error contains pointer to object to handle error code and message
 506  *
 507  * @return newly created object of mc_pipe_t class in success, NULL otherwise
 508  */
 509
 510 mc_pipe_t *
 511 mc_popen (const char *command, GError ** error)
 512 {
 513     mc_pipe_t *p;
 514     const char *const argv[] = { "/bin/sh", "sh", "-c", command, NULL };
 515
 516     p = g_try_new (mc_pipe_t, 1);
 517     if (p == NULL)
 518     {
 519         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE, "%s",
 520                           _("Cannot create pipe descriptor"));
 521         goto ret_err;
 522     }
 523
 524     if (!g_spawn_async_with_pipes
 525         (NULL, (gchar **) argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_FILE_AND_ARGV_ZERO,
 526          NULL, NULL, &p->child_pid, NULL, &p->out.fd, &p->err.fd, error))
 527     {
 528         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE_STREAM, "%s",
 529                           _("Cannot create pipe streams"));
 530         goto ret_err;
 531     }
 532
 533     p->out.buf[0] = '\0';
 534     p->out.len = MC_PIPE_BUFSIZE;
 535     p->out.null_term = FALSE;
 536
 537     p->err.buf[0] = '\0';
 538     p->err.len = MC_PIPE_BUFSIZE;
 539     p->err.null_term = FALSE;
 540
 541     return p;
 542
 543   ret_err:
 544     g_free (p);
 545     return NULL;
 546 }
 547
 548 /* --------------------------------------------------------------------------------------------- */
 549 /**
 550  * Read stdout and stderr of pipe asynchronously.
 551  *
 552  * @parameter p pipe descriptor
 553  *
 554  * The lengths of read data contain in p->out.len and p->err.len.
 555  * Before read, p->xxx.len is an input:
 556  *   p->xxx.len > 0:  do read stream p->xxx and store data in p->xxx.buf;
 557  *   p->xxx.len <= 0: do not read stream p->xxx.
 558  *
 559  * After read, p->xxx.len is an output and contains the following:
 560  *   p->xxx.len > 0: an actual length of read data stored in p->xxx.buf;
 561  *   p->xxx.len == MC_PIPE_STREAM_EOF: EOF of stream p->xxx;
 562  *   p->xxx.len == MC_PIPE_STREAM_UNREAD: stream p->xxx was not read;
 563  *   p->xxx.len == MC_PIPE_ERROR_READ: reading error, and p->xxx.errno is set appropriately.
 564  *
 565  * @paremeter error contains pointer to object to handle error code and message
 566  */
 567
 568 void
 569 mc_pread (mc_pipe_t * p, GError ** error)
 570 {
 571     gboolean read_out, read_err;
 572     fd_set fds;
 573     int maxfd = 0;
 574     int res;
 575
 576     if (error != NULL)
 577         *error = NULL;
 578
 579     read_out = p->out.fd >= 0 && p->out.len > 0;
 580     read_err = p->err.fd >= 0 && p->err.len > 0;
 581
 582     if (!read_out && !read_err)
 583     {
 584         p->out.len = MC_PIPE_STREAM_UNREAD;
 585         p->err.len = MC_PIPE_STREAM_UNREAD;
 586         return;
 587     }
 588
 589     FD_ZERO (&fds);
 590     if (read_out)
 591     {
 592         FD_SET (p->out.fd, &fds);
 593         maxfd = p->out.fd;
 594     }
 595
 596     if (read_err)
 597     {
 598         FD_SET (p->err.fd, &fds);
 599         maxfd = MAX (maxfd, p->err.fd);
 600     }
 601
 602     /* no timeout */
 603     res = select (maxfd + 1, &fds, NULL, NULL, NULL);
 604     if (res < 0 && errno != EINTR)
 605     {
 606         mc_propagate_error (error, MC_PIPE_ERROR_READ,
 607                             _
 608                             ("Unexpected error in select() reading data from a child process:\n%s"),
 609                             unix_error_string (errno));
 610         return;
 611     }
 612
 613     if (read_out)
 614         mc_pread_stream (&p->out, &fds);
 615     else
 616         p->out.len = MC_PIPE_STREAM_UNREAD;
 617
 618     if (read_err)
 619         mc_pread_stream (&p->err, &fds);
 620     else
 621         p->err.len = MC_PIPE_STREAM_UNREAD;
 622 }
 623
 624 /* --------------------------------------------------------------------------------------------- */
 625 /**
 626  * Close pipe and destroy pipe descriptor.
 627  *
 628  * @paremeter p pipe descriptor
 629  * @paremeter error contains pointer to object to handle error code and message
 630  */
 631
 632 void
 633 mc_pclose (mc_pipe_t * p, GError ** error)
 634 {
 635     int res;
 636
 637     if (p->out.fd >= 0)
 638         res = close (p->out.fd);
 639     if (p->err.fd >= 0)
 640         res = close (p->err.fd);
 641
 642     do
 643     {
 644         int status;
 645
 646         res = waitpid (p->child_pid, &status, 0);
 647     }
 648     while (res < 0 && errno == EINTR);
 649
 650     if (res < 0)
 651         mc_replace_error (error, MC_PIPE_ERROR_READ, _("Unexpected error in waitpid():\n%s"),
 652                           unix_error_string (errno));
 653
 654     g_free (p);
 655 }
 656
 657 /* --------------------------------------------------------------------------------------------- */
 658
 659 /**
 660  * Perform tilde expansion if possible.
 661  *
 662  * @param directory pointer to the path
 663  *
 664  * @return newly allocated string, even if it's unchanged.
 665  */
 666
 667 char *
 668 tilde_expand (const char *directory)
 669 {
 670     struct passwd *passwd;
 671     const char *p, *q;
 672
 673     if (*directory != '~')
 674         return g_strdup (directory);
 675
 676     p = directory + 1;
 677
 678     /* d = "~" or d = "~/" */
 679     if (*p == '\0' || IS_PATH_SEP (*p))
 680     {
 681         passwd = getpwuid (geteuid ());
 682         q = IS_PATH_SEP (*p) ? p + 1 : "";
 683     }
 684     else
 685     {
 686         q = strchr (p, PATH_SEP);
 687         if (!q)
 688         {
 689             passwd = getpwnam (p);
 690         }
 691         else
 692         {
 693             char *name;
 694
 695             name = g_strndup (p, q - p);
 696             passwd = getpwnam (name);
 697             q++;
 698             g_free (name);
 699         }
 700     }
 701
 702     /* If we can't figure the user name, leave tilde unexpanded */
 703     if (!passwd)
 704         return g_strdup (directory);
 705
 706     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 707 }
 708
 709 /* --------------------------------------------------------------------------------------------- */
 710 /**
 711  * Creates a pipe to hold standard error for a later analysis.
 712  * The pipe can hold 4096 bytes. Make sure no more is written
 713  * or a deadlock might occur.
 714  */
 715
 716 void
 717 open_error_pipe (void)
 718 {
 719     if (pipe (error_pipe) < 0)
 720     {
 721         message (D_NORMAL, _("Warning"), _("Pipe failed"));
 722     }
 723     old_error = dup (STDERR_FILENO);
 724     if (old_error < 0 || close (STDERR_FILENO) != 0 || dup (error_pipe[1]) != STDERR_FILENO)
 725     {
 726         message (D_NORMAL, _("Warning"), _("Dup failed"));
 727
 728         close (error_pipe[0]);
 729         error_pipe[0] = -1;
 730     }
 731     else
 732     {
 733         /*
 734          * Settng stderr in nonblocking mode as we close it earlier, than
 735          * program stops. We try to read some error at program startup,
 736          * but we should not block on it.
 737          *
 738          * TODO: make piped stdin/stderr poll()/select()able to get rid
 739          * of following hack.
 740          */
 741         int fd_flags;
 742         fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
 743         if (fd_flags != -1)
 744         {
 745             fd_flags |= O_NONBLOCK;
 746             if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
 747             {
 748                 /* TODO: handle it somehow */
 749             }
 750         }
 751     }
 752     /* we never write there */
 753     close (error_pipe[1]);
 754     error_pipe[1] = -1;
 755 }
 756
 757 /* --------------------------------------------------------------------------------------------- */
 758 /**
 759  * Close a pipe
 760  *
 761  * @param error '-1' - ignore errors, '0' - display warning, '1' - display error
 762  * @param text is prepended to the error message from the pipe
 763  *
 764  * @return not 0 if an error was displayed
 765  */
 766
 767 int
 768 close_error_pipe (int error, const char *text)
 769 {
 770     const char *title;
 771     char msg[MAX_PIPE_SIZE];
 772     int len = 0;
 773
 774     /* already closed */
 775     if (error_pipe[0] == -1)
 776         return 0;
 777
 778     if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
 779         title = MSG_ERROR;
 780     else
 781         title = _("Warning");
 782     if (old_error >= 0)
 783     {
 784         if (dup2 (old_error, STDERR_FILENO) == -1)
 785         {
 786             if (error < 0)
 787                 error = D_ERROR;
 788
 789             message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
 790             return 1;
 791         }
 792         close (old_error);
 793         len = read (error_pipe[0], msg, sizeof (msg) - 1);
 794
 795         if (len >= 0)
 796             msg[len] = 0;
 797         close (error_pipe[0]);
 798         error_pipe[0] = -1;
 799     }
 800     if (error < 0)
 801         return 0;               /* Just ignore error message */
 802     if (text == NULL)
 803     {
 804         if (len <= 0)
 805             return 0;           /* Nothing to show */
 806
 807         /* Show message from pipe */
 808         message (error, title, "%s", msg);
 809     }
 810     else
 811     {
 812         /* Show given text and possible message from pipe */
 813         message (error, title, "%s\n%s", text, msg);
 814     }
 815     return 1;
 816 }
 817
 818 /* --------------------------------------------------------------------------------------------- */
 819 /**
 820  * Canonicalize path, and return a new path.  Do everything in place.
 821  * The new path differs from path in:
 822  *      Multiple '/'s are collapsed to a single '/'.
 823  *      Leading './'s and trailing '/.'s are removed.
 824  *      Trailing '/'s are removed.
 825  *      Non-leading '../'s and trailing '..'s are handled by removing
 826  *      portions of the path.
 827  * Well formed UNC paths are modified only in the local part.
 828  */
 829
 830 void
 831 custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 832 {
 833     char *p, *s;
 834     char *lpath = path;         /* path without leading UNC part */
 835     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 836
 837     /* Detect and preserve UNC paths: //server/... */
 838     if ((flags & CANON_PATH_GUARDUNC) != 0 && IS_PATH_SEP (path[0]) && IS_PATH_SEP (path[1]))
 839     {
 840         p = path + 2;
 841         while (p[0] != '\0' && !IS_PATH_SEP (p[0]))
 842             p++;
 843         if (IS_PATH_SEP (p[0]) && p > path + 2)
 844             lpath = p;
 845     }
 846
 847     if (!lpath[0] || !lpath[1])
 848         return;
 849
 850     if (flags & CANON_PATH_JOINSLASHES)
 851     {
 852         /* Collapse multiple slashes */
 853         p = lpath;
 854         while (*p)
 855         {
 856             if (IS_PATH_SEP (p[0]) && IS_PATH_SEP (p[1]) && (p == lpath || *(p - 1) != ':'))
 857             {
 858                 s = p + 1;
 859                 while (IS_PATH_SEP (*(++s)))
 860                     ;
 861                 str_move (p + 1, s);
 862             }
 863             p++;
 864         }
 865     }
 866
 867     if (flags & CANON_PATH_JOINSLASHES)
 868     {
 869         /* Collapse "/./" -> "/" */
 870         p = lpath;
 871         while (*p)
 872         {
 873             if (IS_PATH_SEP (p[0]) && p[1] == '.' && IS_PATH_SEP (p[2]))
 874                 str_move (p, p + 2);
 875             else
 876                 p++;
 877         }
 878     }
 879
 880     if (flags & CANON_PATH_REMSLASHDOTS)
 881     {
 882         size_t len;
 883
 884         /* Remove trailing slashes */
 885         p = lpath + strlen (lpath) - 1;
 886         while (p > lpath && IS_PATH_SEP (*p))
 887         {
 888             if (p >= lpath + url_delim_len - 1
 889                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 890                 break;
 891             *p-- = 0;
 892         }
 893
 894         /* Remove leading "./" */
 895         if (lpath[0] == '.' && IS_PATH_SEP (lpath[1]))
 896         {
 897             if (lpath[2] == 0)
 898             {
 899                 lpath[1] = 0;
 900                 return;
 901             }
 902             else
 903             {
 904                 str_move (lpath, lpath + 2);
 905             }
 906         }
 907
 908         /* Remove trailing "/" or "/." */
 909         len = strlen (lpath);
 910         if (len < 2)
 911             return;
 912         if (IS_PATH_SEP (lpath[len - 1])
 913             && (len < url_delim_len
 914                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 915                             url_delim_len) != 0))
 916         {
 917             lpath[len - 1] = '\0';
 918         }
 919         else
 920         {
 921             if (lpath[len - 1] == '.' && IS_PATH_SEP (lpath[len - 2]))
 922             {
 923                 if (len == 2)
 924                 {
 925                     lpath[1] = '\0';
 926                     return;
 927                 }
 928                 else
 929                 {
 930                     lpath[len - 2] = '\0';
 931                 }
 932             }
 933         }
 934     }
 935
 936     if (flags & CANON_PATH_REMDOUBLEDOTS)
 937     {
 938 #ifdef HAVE_CHARSET
 939         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 940 #endif /* HAVE_CHARSET */
 941
 942         /* Collapse "/.." with the previous part of path */
 943         p = lpath;
 944         while (p[0] && p[1] && p[2])
 945         {
 946             if (!IS_PATH_SEP (p[0]) || p[1] != '.' || p[2] != '.'
 947                 || (!IS_PATH_SEP (p[3]) && p[3] != '\0'))
 948             {
 949                 p++;
 950                 continue;
 951             }
 952
 953             /* search for the previous token */
 954             s = p - 1;
 955             if (s >= lpath + url_delim_len - 2
 956                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 957             {
 958                 s -= (url_delim_len - 2);
 959                 while (s >= lpath && !IS_PATH_SEP (*s--))
 960                     ;
 961             }
 962
 963             while (s >= lpath)
 964             {
 965                 if (s - url_delim_len > lpath
 966                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 967                 {
 968                     char *vfs_prefix = s - url_delim_len;
 969                     vfs_class *vclass;
 970
 971                     while (vfs_prefix > lpath && !IS_PATH_SEP (*--vfs_prefix))
 972                         ;
 973                     if (IS_PATH_SEP (*vfs_prefix))
 974                         vfs_prefix++;
 975                     *(s - url_delim_len) = '\0';
 976
 977                     vclass = vfs_prefix_to_class (vfs_prefix);
 978                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 979
 980                     if (vclass != NULL)
 981                     {
 982                         struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
 983                         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 984                         {
 985                             s = vfs_prefix;
 986                             continue;
 987                         }
 988                     }
 989                 }
 990
 991                 if (IS_PATH_SEP (*s))
 992                     break;
 993
 994                 s--;
 995             }
 996
 997             s++;
 998
 999             /* If the previous token is "..", we cannot collapse it */
1000             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
1001             {
1002                 p += 3;
1003                 continue;
1004             }
1005
1006             if (p[3] != 0)
1007             {
1008                 if (s == lpath && IS_PATH_SEP (*s))
1009                 {
1010                     /* "/../foo" -> "/foo" */
1011                     str_move (s + 1, p + 4);
1012                 }
1013                 else
1014                 {
1015                     /* "token/../foo" -> "foo" */
1016 #ifdef HAVE_CHARSET
1017                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
1018                         && (is_supported_encoding (s + enc_prefix_len)))
1019                         /* special case: remove encoding */
1020                         str_move (s, p + 1);
1021                     else
1022 #endif /* HAVE_CHARSET */
1023                         str_move (s, p + 4);
1024                 }
1025                 p = (s > lpath) ? s - 1 : s;
1026                 continue;
1027             }
1028
1029             /* trailing ".." */
1030             if (s == lpath)
1031             {
1032                 /* "token/.." -> "." */
1033                 if (!IS_PATH_SEP (lpath[0]))
1034                     lpath[0] = '.';
1035                 lpath[1] = '\0';
1036             }
1037             else
1038             {
1039                 /* "foo/token/.." -> "foo" */
1040                 if (s == lpath + 1)
1041                     s[0] = '\0';
1042 #ifdef HAVE_CHARSET
1043                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
1044                          && (is_supported_encoding (s + enc_prefix_len)))
1045                 {
1046                     /* special case: remove encoding */
1047                     s[0] = '.';
1048                     s[1] = '.';
1049                     s[2] = '\0';
1050
1051                     /* search for the previous token */
1052                     /* IS_PATH_SEP (s[-1]) */
1053                     p = s - 1;
1054                     while (p >= lpath && !IS_PATH_SEP (*p))
1055                         p--;
1056
1057                     if (p >= lpath)
1058                         continue;
1059                 }
1060 #endif /* HAVE_CHARSET */
1061                 else
1062                 {
1063                     if (s >= lpath + url_delim_len
1064                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
1065                         *s = '\0';
1066                     else
1067                         s[-1] = '\0';
1068                 }
1069             }
1070
1071             break;
1072         }
1073     }
1074 }
1075
1076 /* --------------------------------------------------------------------------------------------- */
1077
1078 void
1079 canonicalize_pathname (char *path)
1080 {
1081     custom_canonicalize_pathname (path, CANON_PATH_ALL);
1082 }
1083
1084 /* --------------------------------------------------------------------------------------------- */
1085
1086 #ifdef HAVE_GET_PROCESS_STATS
1087 int
1088 gettimeofday (struct timeval *tp, void *tzp)
1089 {
1090     return get_process_stats (tp, PS_SELF, 0, 0);
1091 }
1092 #endif /* HAVE_GET_PROCESS_STATS */
1093
1094 /* --------------------------------------------------------------------------------------------- */
1095
1096 #ifndef HAVE_REALPATH
1097 char *
1098 mc_realpath (const char *path, char *resolved_path)
1099 {
1100     char copy_path[PATH_MAX];
1101     char got_path[PATH_MAX];
1102     char *new_path = got_path;
1103     char *max_path;
1104 #ifdef S_IFLNK
1105     char link_path[PATH_MAX];
1106     int readlinks = 0;
1107     int n;
1108 #endif /* S_IFLNK */
1109
1110     /* Make a copy of the source path since we may need to modify it. */
1111     if (strlen (path) >= PATH_MAX - 2)
1112     {
1113         errno = ENAMETOOLONG;
1114         return NULL;
1115     }
1116     strcpy (copy_path, path);
1117     path = copy_path;
1118     max_path = copy_path + PATH_MAX - 2;
1119     /* If it's a relative pathname use getwd for starters. */
1120     if (!IS_PATH_SEP (*path))
1121     {
1122         new_path = g_get_current_dir ();
1123         if (new_path == NULL)
1124         {
1125             strcpy (got_path, "");
1126         }
1127         else
1128         {
1129             g_snprintf (got_path, sizeof (got_path), "%s", new_path);
1130             g_free (new_path);
1131             new_path = got_path;
1132         }
1133
1134         new_path += strlen (got_path);
1135         if (!IS_PATH_SEP (new_path[-1]))
1136             *new_path++ = PATH_SEP;
1137     }
1138     else
1139     {
1140         *new_path++ = PATH_SEP;
1141         path++;
1142     }
1143     /* Expand each slash-separated pathname component. */
1144     while (*path != '\0')
1145     {
1146         /* Ignore stray "/". */
1147         if (IS_PATH_SEP (*path))
1148         {
1149             path++;
1150             continue;
1151         }
1152         if (*path == '.')
1153         {
1154             /* Ignore ".". */
1155             if (path[1] == '\0' || IS_PATH_SEP (path[1]))
1156             {
1157                 path++;
1158                 continue;
1159             }
1160             if (path[1] == '.')
1161             {
1162                 if (path[2] == '\0' || IS_PATH_SEP (path[2]))
1163                 {
1164                     path += 2;
1165                     /* Ignore ".." at root. */
1166                     if (new_path == got_path + 1)
1167                         continue;
1168                     /* Handle ".." by backing up. */
1169                     while (!IS_PATH_SEP ((--new_path)[-1]))
1170                         ;
1171                     continue;
1172                 }
1173             }
1174         }
1175         /* Safely copy the next pathname component. */
1176         while (*path != '\0' && !IS_PATH_SEP (*path))
1177         {
1178             if (path > max_path)
1179             {
1180                 errno = ENAMETOOLONG;
1181                 return NULL;
1182             }
1183             *new_path++ = *path++;
1184         }
1185 #ifdef S_IFLNK
1186         /* Protect against infinite loops. */
1187         if (readlinks++ > MAXSYMLINKS)
1188         {
1189             errno = ELOOP;
1190             return NULL;
1191         }
1192         /* See if latest pathname component is a symlink. */
1193         *new_path = '\0';
1194         n = readlink (got_path, link_path, PATH_MAX - 1);
1195         if (n < 0)
1196         {
1197             /* EINVAL means the file exists but isn't a symlink. */
1198             if (errno != EINVAL)
1199             {
1200                 /* Make sure it's null terminated. */
1201                 *new_path = '\0';
1202                 strcpy (resolved_path, got_path);
1203                 return NULL;
1204             }
1205         }
1206         else
1207         {
1208             /* Note: readlink doesn't add the null byte. */
1209             link_path[n] = '\0';
1210             if (IS_PATH_SEP (*link_path))
1211                 /* Start over for an absolute symlink. */
1212                 new_path = got_path;
1213             else
1214                 /* Otherwise back up over this component. */
1215                 while (!IS_PATH_SEP (*(--new_path)))
1216                     ;
1217             /* Safe sex check. */
1218             if (strlen (path) + n >= PATH_MAX - 2)
1219             {
1220                 errno = ENAMETOOLONG;
1221                 return NULL;
1222             }
1223             /* Insert symlink contents into path. */
1224             strcat (link_path, path);
1225             strcpy (copy_path, link_path);
1226             path = copy_path;
1227         }
1228 #endif /* S_IFLNK */
1229         *new_path++ = PATH_SEP;
1230     }
1231     /* Delete trailing slash but don't whomp a lone slash. */
1232     if (new_path != got_path + 1 && IS_PATH_SEP (new_path[-1]))
1233         new_path--;
1234     /* Make sure it's null terminated. */
1235     *new_path = '\0';
1236     strcpy (resolved_path, got_path);
1237     return resolved_path;
1238 }
1239 #endif /* HAVE_REALPATH */
1240
1241 /* --------------------------------------------------------------------------------------------- */
1242 /**
1243  * Return the index of the permissions triplet
1244  *
1245  */
1246
1247 int
1248 get_user_permissions (struct stat *st)
1249 {
1250     static gboolean initialized = FALSE;
1251     static gid_t *groups;
1252     static int ngroups;
1253     static uid_t uid;
1254     int i;
1255
1256     if (!initialized)
1257     {
1258         uid = geteuid ();
1259
1260         ngroups = getgroups (0, NULL);
1261         if (ngroups == -1)
1262             ngroups = 0;        /* ignore errors */
1263
1264         /* allocate space for one element in addition to what
1265          * will be filled by getgroups(). */
1266         groups = g_new (gid_t, ngroups + 1);
1267
1268         if (ngroups != 0)
1269         {
1270             ngroups = getgroups (ngroups, groups);
1271             if (ngroups == -1)
1272                 ngroups = 0;    /* ignore errors */
1273         }
1274
1275         /* getgroups() may or may not return the effective group ID,
1276          * so we always include it at the end of the list. */
1277         groups[ngroups++] = getegid ();
1278
1279         initialized = TRUE;
1280     }
1281
1282     if (st->st_uid == uid || uid == 0)
1283         return 0;
1284
1285     for (i = 0; i < ngroups; i++)
1286     {
1287         if (st->st_gid == groups[i])
1288             return 1;
1289     }
1290
1291     return 2;
1292 }
1293
1294 /* --------------------------------------------------------------------------------------------- */
1295 /**
1296  * Build filename from arguments.
1297  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1298  */
1299
1300 char *
1301 mc_build_filenamev (const char *first_element, va_list args)
1302 {
1303     gboolean absolute;
1304     const char *element = first_element;
1305     GString *path;
1306     char *ret;
1307
1308     if (element == NULL)
1309         return NULL;
1310
1311     path = g_string_new ("");
1312
1313     absolute = IS_PATH_SEP (*first_element);
1314
1315     do
1316     {
1317         if (*element == '\0')
1318             element = va_arg (args, char *);
1319         else
1320         {
1321             char *tmp_element;
1322             size_t len;
1323             const char *start;
1324
1325             tmp_element = g_strdup (element);
1326
1327             element = va_arg (args, char *);
1328
1329             canonicalize_pathname (tmp_element);
1330             len = strlen (tmp_element);
1331             start = IS_PATH_SEP (tmp_element[0]) ? tmp_element + 1 : tmp_element;
1332
1333             g_string_append (path, start);
1334             if (!IS_PATH_SEP (tmp_element[len - 1]) && element != NULL)
1335                 g_string_append_c (path, PATH_SEP);
1336
1337             g_free (tmp_element);
1338         }
1339     }
1340     while (element != NULL);
1341
1342     if (absolute)
1343         g_string_prepend_c (path, PATH_SEP);
1344
1345     ret = g_string_free (path, FALSE);
1346     canonicalize_pathname (ret);
1347
1348     return ret;
1349 }
1350
1351 /* --------------------------------------------------------------------------------------------- */
1352 /**
1353  * Build filename from arguments.
1354  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1355  */
1356
1357 char *
1358 mc_build_filename (const char *first_element, ...)
1359 {
1360     va_list args;
1361     char *ret;
1362
1363     if (first_element == NULL)
1364         return NULL;
1365
1366     va_start (args, first_element);
1367     ret = mc_build_filenamev (first_element, args);
1368     va_end (args);
1369     return ret;
1370 }
1371
1372 /* --------------------------------------------------------------------------------------------- */