lib/utilunix.c

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