lib/utilunix.c

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