lib/utilunix.c

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