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