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     static char ibuf[10];
 244     char *name;
 245     static int uid_last;
 246
 247     name = i_cache_match (uid, uid_cache, UID_CACHE_SIZE);
 248     if (name != NULL)
 249         return name;
 250
 251     pwd = getpwuid (uid);
 252     if (pwd != NULL)
 253     {
 254         i_cache_add (uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, &uid_last);
 255         return pwd->pw_name;
 256     }
 257     else
 258     {
 259         g_snprintf (ibuf, sizeof (ibuf), "%d", uid);
 260         return ibuf;
 261     }
 262 }
 263
 264 /* --------------------------------------------------------------------------------------------- */
 265
 266 char *
 267 get_group (int gid)
 268 {
 269     struct group *grp;
 270     static char gbuf[10];
 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         g_snprintf (gbuf, sizeof (gbuf), "%d", gid);
 287         return gbuf;
 288     }
 289 }
 290
 291 /* --------------------------------------------------------------------------------------------- */
 292 /* Since ncurses uses a handler that automatically refreshes the */
 293 /* screen after a SIGCONT, and we don't want this behavior when */
 294 /* spawning a child, we save the original handler here */
 295
 296 void
 297 save_stop_handler (void)
 298 {
 299     sigaction (SIGTSTP, NULL, &startup_handler);
 300 }
 301
 302 /* --------------------------------------------------------------------------------------------- */
 303 /**
 304  * Wrapper for _exit() system call.
 305  * The _exit() function has gcc's attribute 'noreturn', and this is reason why we can't
 306  * mock the call.
 307  *
 308  * @param status exit code
 309  */
 310
 311 void
 312 my_exit (int status)
 313 {
 314     _exit (status);
 315 }
 316
 317 /* --------------------------------------------------------------------------------------------- */
 318 /**
 319  * Call external programs.
 320  *
 321  * @parameter flags   addition conditions for running external programs.
 322  * @parameter shell   shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 323  *                    Shell (or command) will be found in paths described in PATH variable
 324  *                    (if shell parameter doesn't begin from path delimiter)
 325  * @parameter command Command for shell (or first parameter for command, if flags contain EXECUTE_AS_SHELL)
 326  * @return 0 if successfull, -1 otherwise
 327  */
 328
 329 int
 330 my_system (int flags, const char *shell, const char *command)
 331 {
 332     return my_systeml (flags, shell, command, NULL);
 333 }
 334
 335 /* --------------------------------------------------------------------------------------------- */
 336 /**
 337  * Call external programs with various parameters number.
 338  *
 339  * @parameter flags addition conditions for running external programs.
 340  * @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 341  *                  Shell (or command) will be found in pathes described in PATH variable
 342  *                  (if shell parameter doesn't begin from path delimiter)
 343  * @parameter ...   Command for shell with addition parameters for shell
 344  *                  (or parameters for command, if flags contain EXECUTE_AS_SHELL).
 345  *                  Should be NULL terminated.
 346  * @return 0 if successfull, -1 otherwise
 347  */
 348
 349
 350 int
 351 my_systeml (int flags, const char *shell, ...)
 352 {
 353     GPtrArray *args_array;
 354     int status = 0;
 355     va_list vargs;
 356     char *one_arg;
 357
 358     args_array = g_ptr_array_new ();
 359
 360     va_start (vargs, shell);
 361     while ((one_arg = va_arg (vargs, char *)) != NULL)
 362           g_ptr_array_add (args_array, one_arg);
 363     va_end (vargs);
 364
 365     g_ptr_array_add (args_array, NULL);
 366     status = my_systemv_flags (flags, shell, (char *const *) args_array->pdata);
 367
 368     g_ptr_array_free (args_array, TRUE);
 369
 370     return status;
 371 }
 372
 373 /* --------------------------------------------------------------------------------------------- */
 374 /**
 375  * Call external programs with array of strings as parameters.
 376  *
 377  * @parameter command command to run. Command will be found in paths described in PATH variable
 378  *                    (if command parameter doesn't begin from path delimiter)
 379  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 380  * @return 0 if successfull, -1 otherwise
 381  */
 382
 383 int
 384 my_systemv (const char *command, char *const argv[])
 385 {
 386     my_fork_state_t fork_state;
 387     int status = 0;
 388     my_system_sigactions_t sigactions;
 389
 390     my_system__save_sigaction_handlers (&sigactions);
 391
 392     fork_state = my_fork ();
 393     switch (fork_state)
 394     {
 395     case FORK_ERROR:
 396         status = -1;
 397         break;
 398     case FORK_CHILD:
 399         {
 400             signal (SIGINT, SIG_DFL);
 401             signal (SIGQUIT, SIG_DFL);
 402             signal (SIGTSTP, SIG_DFL);
 403             signal (SIGCHLD, SIG_DFL);
 404
 405             execvp (command, argv);
 406             my_exit (127);      /* Exec error */
 407         }
 408         break;
 409     default:
 410         status = 0;
 411         break;
 412     }
 413     my_system__restore_sigaction_handlers (&sigactions);
 414
 415     return status;
 416 }
 417
 418 /* --------------------------------------------------------------------------------------------- */
 419 /**
 420  * Call external programs with flags and with array of strings as parameters.
 421  *
 422  * @parameter flags   addition conditions for running external programs.
 423  * @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 424  *                    Shell (or command) will be found in paths described in PATH variable
 425  *                    (if shell parameter doesn't begin from path delimiter)
 426  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 427  * @return 0 if successfull, -1 otherwise
 428  */
 429
 430 int
 431 my_systemv_flags (int flags, const char *command, char *const argv[])
 432 {
 433     char *execute_name = NULL;
 434     GPtrArray *args_array;
 435     int status = 0;
 436
 437     args_array = my_system_make_arg_array (flags, command, &execute_name);
 438
 439     for (; argv != NULL && *argv != NULL; argv++)
 440         g_ptr_array_add (args_array, *argv);
 441
 442     g_ptr_array_add (args_array, NULL);
 443     status = my_systemv (execute_name, (char *const *) args_array->pdata);
 444
 445     g_free (execute_name);
 446     g_ptr_array_free (args_array, TRUE);
 447
 448     return status;
 449 }
 450
 451 /* --------------------------------------------------------------------------------------------- */
 452
 453 /**
 454  * Perform tilde expansion if possible.
 455  *
 456  * @param directory pointer to the path
 457  *
 458  * @return newly allocated string, even if it's unchanged.
 459  */
 460
 461 char *
 462 tilde_expand (const char *directory)
 463 {
 464     struct passwd *passwd;
 465     const char *p, *q;
 466     char *name;
 467
 468     if (*directory != '~')
 469         return g_strdup (directory);
 470
 471     p = directory + 1;
 472
 473     /* d = "~" or d = "~/" */
 474     if (!(*p) || (*p == PATH_SEP))
 475     {
 476         passwd = getpwuid (geteuid ());
 477         q = (*p == PATH_SEP) ? p + 1 : "";
 478     }
 479     else
 480     {
 481         q = strchr (p, PATH_SEP);
 482         if (!q)
 483         {
 484             passwd = getpwnam (p);
 485         }
 486         else
 487         {
 488             name = g_strndup (p, q - p);
 489             passwd = getpwnam (name);
 490             q++;
 491             g_free (name);
 492         }
 493     }
 494
 495     /* If we can't figure the user name, leave tilde unexpanded */
 496     if (!passwd)
 497         return g_strdup (directory);
 498
 499     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 500 }
 501
 502 /* --------------------------------------------------------------------------------------------- */
 503 /**
 504  * Creates a pipe to hold standard error for a later analysis.
 505  * The pipe can hold 4096 bytes. Make sure no more is written
 506  * or a deadlock might occur.
 507  */
 508
 509 void
 510 open_error_pipe (void)
 511 {
 512     if (pipe (error_pipe) < 0)
 513     {
 514         message (D_NORMAL, _("Warning"), _("Pipe failed"));
 515     }
 516     old_error = dup (2);
 517     if (old_error < 0 || close (2) || dup (error_pipe[1]) != 2)
 518     {
 519         message (D_NORMAL, _("Warning"), _("Dup failed"));
 520
 521         close (error_pipe[0]);
 522         error_pipe[0] = -1;
 523     }
 524     else
 525     {
 526         /*
 527          * Settng stderr in nonblocking mode as we close it earlier, than
 528          * program stops. We try to read some error at program startup,
 529          * but we should not block on it.
 530          *
 531          * TODO: make piped stdin/stderr poll()/select()able to get rid
 532          * of following hack.
 533          */
 534         int fd_flags;
 535         fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
 536         if (fd_flags != -1)
 537         {
 538             fd_flags |= O_NONBLOCK;
 539             if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
 540             {
 541                 /* TODO: handle it somehow */
 542             }
 543         }
 544     }
 545     /* we never write there */
 546     close (error_pipe[1]);
 547     error_pipe[1] = -1;
 548 }
 549
 550 /* --------------------------------------------------------------------------------------------- */
 551 /**
 552  * Close a pipe
 553  *
 554  * @param error '-1' - ignore errors, '0' - display warning, '1' - display error
 555  * @param text is prepended to the error message from the pipe
 556  *
 557  * @return not 0 if an error was displayed
 558  */
 559
 560 int
 561 close_error_pipe (int error, const char *text)
 562 {
 563     const char *title;
 564     char msg[MAX_PIPE_SIZE];
 565     int len = 0;
 566
 567     /* already closed */
 568     if (error_pipe[0] == -1)
 569         return 0;
 570
 571     if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
 572         title = MSG_ERROR;
 573     else
 574         title = _("Warning");
 575     if (old_error >= 0)
 576     {
 577         if (dup2 (old_error, 2) == -1)
 578         {
 579             if (error < 0)
 580                 error = D_ERROR;
 581
 582             message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
 583             return 1;
 584         }
 585         close (old_error);
 586         len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
 587
 588         if (len >= 0)
 589             msg[len] = 0;
 590         close (error_pipe[0]);
 591         error_pipe[0] = -1;
 592     }
 593     if (error < 0)
 594         return 0;               /* Just ignore error message */
 595     if (text == NULL)
 596     {
 597         if (len <= 0)
 598             return 0;           /* Nothing to show */
 599
 600         /* Show message from pipe */
 601         message (error, title, "%s", msg);
 602     }
 603     else
 604     {
 605         /* Show given text and possible message from pipe */
 606         message (error, title, "%s\n%s", text, msg);
 607     }
 608     return 1;
 609 }
 610
 611 /* --------------------------------------------------------------------------------------------- */
 612 /**
 613  * Canonicalize path, and return a new path.  Do everything in place.
 614  * The new path differs from path in:
 615  *      Multiple `/'s are collapsed to a single `/'.
 616  *      Leading `./'s and trailing `/.'s are removed.
 617  *      Trailing `/'s are removed.
 618  *      Non-leading `../'s and trailing `..'s are handled by removing
 619  *      portions of the path.
 620  * Well formed UNC paths are modified only in the local part.
 621  */
 622
 623 void
 624 custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 625 {
 626     char *p, *s;
 627     size_t len;
 628     char *lpath = path;         /* path without leading UNC part */
 629     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 630
 631     /* Detect and preserve UNC paths: //server/... */
 632     if ((flags & CANON_PATH_GUARDUNC) && path[0] == PATH_SEP && path[1] == PATH_SEP)
 633     {
 634         p = path + 2;
 635         while (p[0] && p[0] != '/')
 636             p++;
 637         if (p[0] == '/' && p > path + 2)
 638             lpath = p;
 639     }
 640
 641     if (!lpath[0] || !lpath[1])
 642         return;
 643
 644     if (flags & CANON_PATH_JOINSLASHES)
 645     {
 646         /* Collapse multiple slashes */
 647         p = lpath;
 648         while (*p)
 649         {
 650             if (p[0] == PATH_SEP && p[1] == PATH_SEP && (p == lpath || *(p - 1) != ':'))
 651             {
 652                 s = p + 1;
 653                 while (*(++s) == PATH_SEP);
 654                 str_move (p + 1, s);
 655             }
 656             p++;
 657         }
 658     }
 659
 660     if (flags & CANON_PATH_JOINSLASHES)
 661     {
 662         /* Collapse "/./" -> "/" */
 663         p = lpath;
 664         while (*p)
 665         {
 666             if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
 667                 str_move (p, p + 2);
 668             else
 669                 p++;
 670         }
 671     }
 672
 673     if (flags & CANON_PATH_REMSLASHDOTS)
 674     {
 675         /* Remove trailing slashes */
 676         p = lpath + strlen (lpath) - 1;
 677         while (p > lpath && *p == PATH_SEP)
 678         {
 679             if (p >= lpath - (url_delim_len + 1)
 680                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 681                 break;
 682             *p-- = 0;
 683         }
 684
 685         /* Remove leading "./" */
 686         if (lpath[0] == '.' && lpath[1] == PATH_SEP)
 687         {
 688             if (lpath[2] == 0)
 689             {
 690                 lpath[1] = 0;
 691                 return;
 692             }
 693             else
 694             {
 695                 str_move (lpath, lpath + 2);
 696             }
 697         }
 698
 699         /* Remove trailing "/" or "/." */
 700         len = strlen (lpath);
 701         if (len < 2)
 702             return;
 703         if (lpath[len - 1] == PATH_SEP
 704             && (len < url_delim_len
 705                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 706                             url_delim_len) != 0))
 707         {
 708             lpath[len - 1] = '\0';
 709         }
 710         else
 711         {
 712             if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP)
 713             {
 714                 if (len == 2)
 715                 {
 716                     lpath[1] = '\0';
 717                     return;
 718                 }
 719                 else
 720                 {
 721                     lpath[len - 2] = '\0';
 722                 }
 723             }
 724         }
 725     }
 726
 727     if (flags & CANON_PATH_REMDOUBLEDOTS)
 728     {
 729 #ifdef HAVE_CHARSET
 730         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 731 #endif /* HAVE_CHARSET */
 732
 733         /* Collapse "/.." with the previous part of path */
 734         p = lpath;
 735         while (p[0] && p[1] && p[2])
 736         {
 737             if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.') || (p[3] != PATH_SEP && p[3] != 0))
 738             {
 739                 p++;
 740                 continue;
 741             }
 742
 743             /* search for the previous token */
 744             s = p - 1;
 745             if (s >= lpath + url_delim_len - 2
 746                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 747             {
 748                 s -= (url_delim_len - 2);
 749                 while (s >= lpath && *s-- != PATH_SEP);
 750             }
 751
 752             while (s >= lpath)
 753             {
 754                 if (s - url_delim_len > lpath
 755                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 756                 {
 757                     char *vfs_prefix = s - url_delim_len;
 758                     struct vfs_class *vclass;
 759
 760                     while (vfs_prefix > lpath && *--vfs_prefix != PATH_SEP);
 761                     if (*vfs_prefix == PATH_SEP)
 762                         vfs_prefix++;
 763                     *(s - url_delim_len) = '\0';
 764
 765                     vclass = vfs_prefix_to_class (vfs_prefix);
 766                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 767
 768                     if (vclass != NULL)
 769                     {
 770                         struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
 771                         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 772                         {
 773                             s = vfs_prefix;
 774                             continue;
 775                         }
 776                     }
 777                 }
 778
 779                 if (*s == PATH_SEP)
 780                     break;
 781
 782                 s--;
 783             }
 784
 785             s++;
 786
 787             /* If the previous token is "..", we cannot collapse it */
 788             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
 789             {
 790                 p += 3;
 791                 continue;
 792             }
 793
 794             if (p[3] != 0)
 795             {
 796                 if (s == lpath && *s == PATH_SEP)
 797                 {
 798                     /* "/../foo" -> "/foo" */
 799                     str_move (s + 1, p + 4);
 800                 }
 801                 else
 802                 {
 803                     /* "token/../foo" -> "foo" */
 804 #ifdef HAVE_CHARSET
 805                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 806                         && (is_supported_encoding (s + enc_prefix_len)))
 807                         /* special case: remove encoding */
 808                         str_move (s, p + 1);
 809                     else
 810 #endif /* HAVE_CHARSET */
 811                         str_move (s, p + 4);
 812                 }
 813                 p = (s > lpath) ? s - 1 : s;
 814                 continue;
 815             }
 816
 817             /* trailing ".." */
 818             if (s == lpath)
 819             {
 820                 /* "token/.." -> "." */
 821                 if (lpath[0] != PATH_SEP)
 822                 {
 823                     lpath[0] = '.';
 824                 }
 825                 lpath[1] = 0;
 826             }
 827             else
 828             {
 829                 /* "foo/token/.." -> "foo" */
 830                 if (s == lpath + 1)
 831                     s[0] = 0;
 832 #ifdef HAVE_CHARSET
 833                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 834                          && (is_supported_encoding (s + enc_prefix_len)))
 835                 {
 836                     /* special case: remove encoding */
 837                     s[0] = '.';
 838                     s[1] = '.';
 839                     s[2] = '\0';
 840
 841                     /* search for the previous token */
 842                     /* s[-1] == PATH_SEP */
 843                     p = s - 1;
 844                     while (p >= lpath && *p != PATH_SEP)
 845                         p--;
 846
 847                     if (p != NULL)
 848                         continue;
 849                 }
 850 #endif /* HAVE_CHARSET */
 851                 else
 852                 {
 853                     if (s >= lpath + url_delim_len
 854                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 855                         *s = '\0';
 856                     else
 857                         s[-1] = '\0';
 858                 }
 859                 break;
 860             }
 861
 862             break;
 863         }
 864     }
 865 }
 866
 867 /* --------------------------------------------------------------------------------------------- */
 868
 869 void
 870 canonicalize_pathname (char *path)
 871 {
 872     custom_canonicalize_pathname (path, CANON_PATH_ALL);
 873 }
 874
 875 /* --------------------------------------------------------------------------------------------- */
 876
 877 #ifdef HAVE_GET_PROCESS_STATS
 878 int
 879 gettimeofday (struct timeval *tp, void *tzp)
 880 {
 881     return get_process_stats (tp, PS_SELF, 0, 0);
 882 }
 883 #endif /* HAVE_GET_PROCESS_STATS */
 884
 885 /* --------------------------------------------------------------------------------------------- */
 886
 887 #ifndef HAVE_REALPATH
 888 char *
 889 mc_realpath (const char *path, char *resolved_path)
 890 {
 891     char copy_path[PATH_MAX];
 892     char link_path[PATH_MAX];
 893     char got_path[PATH_MAX];
 894     char *new_path = got_path;
 895     char *max_path;
 896     int readlinks = 0;
 897     int n;
 898
 899     /* Make a copy of the source path since we may need to modify it. */
 900     if (strlen (path) >= PATH_MAX - 2)
 901     {
 902         errno = ENAMETOOLONG;
 903         return NULL;
 904     }
 905     strcpy (copy_path, path);
 906     path = copy_path;
 907     max_path = copy_path + PATH_MAX - 2;
 908     /* If it's a relative pathname use getwd for starters. */
 909     if (*path != '/')
 910     {
 911
 912         new_path = g_get_current_dir ();
 913         if (new_path == NULL)
 914         {
 915             strcpy (got_path, "");
 916         }
 917         else
 918         {
 919             g_snprintf (got_path, PATH_MAX, "%s", new_path);
 920             g_free (new_path);
 921             new_path = got_path;
 922         }
 923
 924         new_path += strlen (got_path);
 925         if (new_path[-1] != '/')
 926             *new_path++ = '/';
 927     }
 928     else
 929     {
 930         *new_path++ = '/';
 931         path++;
 932     }
 933     /* Expand each slash-separated pathname component. */
 934     while (*path != '\0')
 935     {
 936         /* Ignore stray "/". */
 937         if (*path == '/')
 938         {
 939             path++;
 940             continue;
 941         }
 942         if (*path == '.')
 943         {
 944             /* Ignore ".". */
 945             if (path[1] == '\0' || path[1] == '/')
 946             {
 947                 path++;
 948                 continue;
 949             }
 950             if (path[1] == '.')
 951             {
 952                 if (path[2] == '\0' || path[2] == '/')
 953                 {
 954                     path += 2;
 955                     /* Ignore ".." at root. */
 956                     if (new_path == got_path + 1)
 957                         continue;
 958                     /* Handle ".." by backing up. */
 959                     while ((--new_path)[-1] != '/');
 960                     continue;
 961                 }
 962             }
 963         }
 964         /* Safely copy the next pathname component. */
 965         while (*path != '\0' && *path != '/')
 966         {
 967             if (path > max_path)
 968             {
 969                 errno = ENAMETOOLONG;
 970                 return NULL;
 971             }
 972             *new_path++ = *path++;
 973         }
 974 #ifdef S_IFLNK
 975         /* Protect against infinite loops. */
 976         if (readlinks++ > MAXSYMLINKS)
 977         {
 978             errno = ELOOP;
 979             return NULL;
 980         }
 981         /* See if latest pathname component is a symlink. */
 982         *new_path = '\0';
 983         n = readlink (got_path, link_path, PATH_MAX - 1);
 984         if (n < 0)
 985         {
 986             /* EINVAL means the file exists but isn't a symlink. */
 987             if (errno != EINVAL)
 988             {
 989                 /* Make sure it's null terminated. */
 990                 *new_path = '\0';
 991                 strcpy (resolved_path, got_path);
 992                 return NULL;
 993             }
 994         }
 995         else
 996         {
 997             /* Note: readlink doesn't add the null byte. */
 998             link_path[n] = '\0';
 999             if (*link_path == '/')
1000                 /* Start over for an absolute symlink. */
1001                 new_path = got_path;
1002             else
1003                 /* Otherwise back up over this component. */
1004                 while (*(--new_path) != '/');
1005             /* Safe sex check. */
1006             if (strlen (path) + n >= PATH_MAX - 2)
1007             {
1008                 errno = ENAMETOOLONG;
1009                 return NULL;
1010             }
1011             /* Insert symlink contents into path. */
1012             strcat (link_path, path);
1013             strcpy (copy_path, link_path);
1014             path = copy_path;
1015         }
1016 #endif /* S_IFLNK */
1017         *new_path++ = '/';
1018     }
1019     /* Delete trailing slash but don't whomp a lone slash. */
1020     if (new_path != got_path + 1 && new_path[-1] == '/')
1021         new_path--;
1022     /* Make sure it's null terminated. */
1023     *new_path = '\0';
1024     strcpy (resolved_path, got_path);
1025     return resolved_path;
1026 }
1027 #endif /* HAVE_REALPATH */
1028
1029 /* --------------------------------------------------------------------------------------------- */
1030 /**
1031  * Return the index of the permissions triplet
1032  *
1033  */
1034
1035 int
1036 get_user_permissions (struct stat *st)
1037 {
1038     static gboolean initialized = FALSE;
1039     static gid_t *groups;
1040     static int ngroups;
1041     static uid_t uid;
1042     int i;
1043
1044     if (!initialized)
1045     {
1046         uid = geteuid ();
1047
1048         ngroups = getgroups (0, NULL);
1049         if (ngroups == -1)
1050             ngroups = 0;        /* ignore errors */
1051
1052         /* allocate space for one element in addition to what
1053          * will be filled by getgroups(). */
1054         groups = g_new (gid_t, ngroups + 1);
1055
1056         if (ngroups != 0)
1057         {
1058             ngroups = getgroups (ngroups, groups);
1059             if (ngroups == -1)
1060                 ngroups = 0;    /* ignore errors */
1061         }
1062
1063         /* getgroups() may or may not return the effective group ID,
1064          * so we always include it at the end of the list. */
1065         groups[ngroups++] = getegid ();
1066
1067         initialized = TRUE;
1068     }
1069
1070     if (st->st_uid == uid || uid == 0)
1071         return 0;
1072
1073     for (i = 0; i < ngroups; i++)
1074     {
1075         if (st->st_gid == groups[i])
1076             return 1;
1077     }
1078
1079     return 2;
1080 }
1081
1082 /* --------------------------------------------------------------------------------------------- */
1083 /**
1084  * Build filename from arguments.
1085  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1086  */
1087
1088 char *
1089 mc_build_filenamev (const char *first_element, va_list args)
1090 {
1091     gboolean absolute;
1092     const char *element = first_element;
1093     GString *path;
1094     char *ret;
1095
1096     if (element == NULL)
1097         return NULL;
1098
1099     path = g_string_new ("");
1100
1101     absolute = (*first_element != '\0' && *first_element == PATH_SEP);
1102
1103     do
1104     {
1105         if (*element == '\0')
1106             element = va_arg (args, char *);
1107         else
1108         {
1109             char *tmp_element;
1110             size_t len;
1111             const char *start;
1112
1113             tmp_element = g_strdup (element);
1114
1115             element = va_arg (args, char *);
1116
1117             canonicalize_pathname (tmp_element);
1118             len = strlen (tmp_element);
1119             start = (tmp_element[0] == PATH_SEP) ? tmp_element + 1 : tmp_element;
1120
1121             g_string_append (path, start);
1122             if (tmp_element[len - 1] != PATH_SEP && element != NULL)
1123                 g_string_append_c (path, PATH_SEP);
1124
1125             g_free (tmp_element);
1126         }
1127     }
1128     while (element != NULL);
1129
1130     if (absolute)
1131         g_string_prepend_c (path, PATH_SEP);
1132
1133     ret = g_string_free (path, FALSE);
1134     canonicalize_pathname (ret);
1135
1136     return ret;
1137 }
1138
1139 /* --------------------------------------------------------------------------------------------- */
1140 /**
1141  * Build filename from arguments.
1142  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1143  */
1144
1145 char *
1146 mc_build_filename (const char *first_element, ...)
1147 {
1148     va_list args;
1149     char *ret;
1150
1151     if (first_element == NULL)
1152         return NULL;
1153
1154     va_start (args, first_element);
1155     ret = mc_build_filenamev (first_element, args);
1156     va_end (args);
1157     return ret;
1158 }
1159
1160 /* --------------------------------------------------------------------------------------------- */