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
   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 /*** file scope variables ************************************************************************/
 100
 101 static int_cache uid_cache[UID_CACHE_SIZE];
 102 static int_cache gid_cache[GID_CACHE_SIZE];
 103
 104 static int error_pipe[2];       /* File descriptors of error pipe */
 105 static int old_error;           /* File descriptor of old standard error */
 106
 107 /*** file scope functions ************************************************************************/
 108 /* --------------------------------------------------------------------------------------------- */
 109
 110 static char *
 111 i_cache_match (int id, int_cache * cache, int size)
 112 {
 113     int i;
 114
 115     for (i = 0; i < size; i++)
 116         if (cache[i].index == id)
 117             return cache[i].string;
 118     return 0;
 119 }
 120
 121 /* --------------------------------------------------------------------------------------------- */
 122
 123 static void
 124 i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
 125 {
 126     g_free (cache[*last].string);
 127     cache[*last].string = g_strdup (text);
 128     cache[*last].index = id;
 129     *last = ((*last) + 1) % size;
 130 }
 131
 132 /* --------------------------------------------------------------------------------------------- */
 133 /*** public functions ****************************************************************************/
 134 /* --------------------------------------------------------------------------------------------- */
 135
 136 char *
 137 get_owner (int uid)
 138 {
 139     struct passwd *pwd;
 140     static char ibuf[10];
 141     char *name;
 142     static int uid_last;
 143
 144     name = i_cache_match (uid, uid_cache, UID_CACHE_SIZE);
 145     if (name != NULL)
 146         return name;
 147
 148     pwd = getpwuid (uid);
 149     if (pwd != NULL)
 150     {
 151         i_cache_add (uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, &uid_last);
 152         return pwd->pw_name;
 153     }
 154     else
 155     {
 156         g_snprintf (ibuf, sizeof (ibuf), "%d", uid);
 157         return ibuf;
 158     }
 159 }
 160
 161 /* --------------------------------------------------------------------------------------------- */
 162
 163 char *
 164 get_group (int gid)
 165 {
 166     struct group *grp;
 167     static char gbuf[10];
 168     char *name;
 169     static int gid_last;
 170
 171     name = i_cache_match (gid, gid_cache, GID_CACHE_SIZE);
 172     if (name != NULL)
 173         return name;
 174
 175     grp = getgrgid (gid);
 176     if (grp != NULL)
 177     {
 178         i_cache_add (gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, &gid_last);
 179         return grp->gr_name;
 180     }
 181     else
 182     {
 183         g_snprintf (gbuf, sizeof (gbuf), "%d", gid);
 184         return gbuf;
 185     }
 186 }
 187
 188 /* --------------------------------------------------------------------------------------------- */
 189 /* Since ncurses uses a handler that automatically refreshes the */
 190 /* screen after a SIGCONT, and we don't want this behavior when */
 191 /* spawning a child, we save the original handler here */
 192
 193 void
 194 save_stop_handler (void)
 195 {
 196     sigaction (SIGTSTP, NULL, &startup_handler);
 197 }
 198
 199 /* --------------------------------------------------------------------------------------------- */
 200
 201 int
 202 my_system (int flags, const char *shell, const char *command)
 203 {
 204     struct sigaction ignore, save_intr, save_quit, save_stop;
 205     pid_t pid;
 206     int status = 0;
 207
 208     ignore.sa_handler = SIG_IGN;
 209     sigemptyset (&ignore.sa_mask);
 210     ignore.sa_flags = 0;
 211
 212     sigaction (SIGINT, &ignore, &save_intr);
 213     sigaction (SIGQUIT, &ignore, &save_quit);
 214
 215     /* Restore the original SIGTSTP handler, we don't want ncurses' */
 216     /* handler messing the screen after the SIGCONT */
 217     sigaction (SIGTSTP, &startup_handler, &save_stop);
 218
 219     pid = fork ();
 220     if (pid < 0)
 221     {
 222         fprintf (stderr, "\n\nfork () = -1\n");
 223         status = -1;
 224     }
 225     else if (pid == 0)
 226     {
 227         signal (SIGINT, SIG_DFL);
 228         signal (SIGQUIT, SIG_DFL);
 229         signal (SIGTSTP, SIG_DFL);
 230         signal (SIGCHLD, SIG_DFL);
 231
 232         if (flags & EXECUTE_AS_SHELL)
 233             execl (shell, shell, "-c", command, (char *) NULL);
 234         else
 235         {
 236             gchar **shell_tokens;
 237             const gchar *only_cmd;
 238
 239             shell_tokens = g_strsplit (shell, " ", 2);
 240             if (shell_tokens == NULL)
 241                 only_cmd = shell;
 242             else
 243                 only_cmd = (*shell_tokens != NULL) ? *shell_tokens : shell;
 244
 245             execlp (only_cmd, shell, command, (char *) NULL);
 246
 247             /*
 248                execlp will replace current process,
 249                therefore no sence in call of g_strfreev().
 250                But this keeped for estetic reason :)
 251              */
 252             g_strfreev (shell_tokens);
 253
 254         }
 255
 256         _exit (127);            /* Exec error */
 257     }
 258     else
 259     {
 260         while (TRUE)
 261         {
 262             if (waitpid (pid, &status, 0) > 0)
 263             {
 264                 status = WEXITSTATUS (status);
 265                 break;
 266             }
 267             if (errno != EINTR)
 268             {
 269                 status = -1;
 270                 break;
 271             }
 272         }
 273     }
 274     sigaction (SIGINT, &save_intr, NULL);
 275     sigaction (SIGQUIT, &save_quit, NULL);
 276     sigaction (SIGTSTP, &save_stop, NULL);
 277
 278     return status;
 279 }
 280
 281
 282 /* --------------------------------------------------------------------------------------------- */
 283 /**
 284  * Perform tilde expansion if possible.
 285  * Always return a newly allocated string, even if it's unchanged.
 286  */
 287
 288 char *
 289 tilde_expand (const char *directory)
 290 {
 291     struct passwd *passwd;
 292     const char *p, *q;
 293     char *name;
 294
 295     if (*directory != '~')
 296         return g_strdup (directory);
 297
 298     p = directory + 1;
 299
 300     /* d = "~" or d = "~/" */
 301     if (!(*p) || (*p == PATH_SEP))
 302     {
 303         passwd = getpwuid (geteuid ());
 304         q = (*p == PATH_SEP) ? p + 1 : "";
 305     }
 306     else
 307     {
 308         q = strchr (p, PATH_SEP);
 309         if (!q)
 310         {
 311             passwd = getpwnam (p);
 312         }
 313         else
 314         {
 315             name = g_strndup (p, q - p);
 316             passwd = getpwnam (name);
 317             q++;
 318             g_free (name);
 319         }
 320     }
 321
 322     /* If we can't figure the user name, leave tilde unexpanded */
 323     if (!passwd)
 324         return g_strdup (directory);
 325
 326     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 327 }
 328
 329 /* --------------------------------------------------------------------------------------------- */
 330 /**
 331  * Creates a pipe to hold standard error for a later analysis.
 332  * The pipe can hold 4096 bytes. Make sure no more is written
 333  * or a deadlock might occur.
 334  */
 335
 336 void
 337 open_error_pipe (void)
 338 {
 339     if (pipe (error_pipe) < 0)
 340     {
 341         message (D_NORMAL, _("Warning"), _("Pipe failed"));
 342     }
 343     old_error = dup (2);
 344     if (old_error < 0 || close (2) || dup (error_pipe[1]) != 2)
 345     {
 346         message (D_NORMAL, _("Warning"), _("Dup failed"));
 347
 348         close (error_pipe[0]);
 349         error_pipe[0] = -1;
 350     }
 351     else
 352     {
 353         /*
 354          * Settng stderr in nonblocking mode as we close it earlier, than
 355          * program stops. We try to read some error at program startup,
 356          * but we should not block on it.
 357          *
 358          * TODO: make piped stdin/stderr poll()/select()able to get rid
 359          * of following hack.
 360          */
 361         int fd_flags;
 362         fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
 363         if (fd_flags != -1)
 364         {
 365             fd_flags |= O_NONBLOCK;
 366             if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
 367             {
 368                 /* TODO: handle it somehow */
 369             }
 370         }
 371     }
 372     /* we never write there */
 373     close (error_pipe[1]);
 374     error_pipe[1] = -1;
 375 }
 376
 377 /* --------------------------------------------------------------------------------------------- */
 378 /**
 379  * Returns true if an error was displayed
 380  * error: -1 - ignore errors, 0 - display warning, 1 - display error
 381  * text is prepended to the error message from the pipe
 382  */
 383
 384 int
 385 close_error_pipe (int error, const char *text)
 386 {
 387     const char *title;
 388     char msg[MAX_PIPE_SIZE];
 389     int len = 0;
 390
 391     /* already closed */
 392     if (error_pipe[0] == -1)
 393         return 0;
 394
 395     if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
 396         title = MSG_ERROR;
 397     else
 398         title = _("Warning");
 399     if (old_error >= 0)
 400     {
 401         if (dup2 (old_error, 2) == -1)
 402         {
 403             if (error < 0)
 404                 error = D_ERROR;
 405
 406             message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
 407             return 1;
 408         }
 409         close (old_error);
 410         len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
 411
 412         if (len >= 0)
 413             msg[len] = 0;
 414         close (error_pipe[0]);
 415         error_pipe[0] = -1;
 416     }
 417     if (error < 0)
 418         return 0;               /* Just ignore error message */
 419     if (text == NULL)
 420     {
 421         if (len <= 0)
 422             return 0;           /* Nothing to show */
 423
 424         /* Show message from pipe */
 425         message (error, title, "%s", msg);
 426     }
 427     else
 428     {
 429         /* Show given text and possible message from pipe */
 430         message (error, title, "%s\n%s", text, msg);
 431     }
 432     return 1;
 433 }
 434
 435 /* --------------------------------------------------------------------------------------------- */
 436 /**
 437  * Canonicalize path, and return a new path.  Do everything in place.
 438  * The new path differs from path in:
 439  *      Multiple `/'s are collapsed to a single `/'.
 440  *      Leading `./'s and trailing `/.'s are removed.
 441  *      Trailing `/'s are removed.
 442  *      Non-leading `../'s and trailing `..'s are handled by removing
 443  *      portions of the path.
 444  * Well formed UNC paths are modified only in the local part.
 445  */
 446
 447 void
 448 custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 449 {
 450     char *p, *s;
 451     size_t len;
 452     char *lpath = path;         /* path without leading UNC part */
 453     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 454
 455     /* Detect and preserve UNC paths: //server/... */
 456     if ((flags & CANON_PATH_GUARDUNC) && path[0] == PATH_SEP && path[1] == PATH_SEP)
 457     {
 458         p = path + 2;
 459         while (p[0] && p[0] != '/')
 460             p++;
 461         if (p[0] == '/' && p > path + 2)
 462             lpath = p;
 463     }
 464
 465     if (!lpath[0] || !lpath[1])
 466         return;
 467
 468     if (flags & CANON_PATH_JOINSLASHES)
 469     {
 470         /* Collapse multiple slashes */
 471         p = lpath;
 472         while (*p)
 473         {
 474             if (p[0] == PATH_SEP && p[1] == PATH_SEP && (p == lpath || *(p - 1) != ':'))
 475             {
 476                 s = p + 1;
 477                 while (*(++s) == PATH_SEP);
 478                 str_move (p + 1, s);
 479             }
 480             p++;
 481         }
 482     }
 483
 484     if (flags & CANON_PATH_JOINSLASHES)
 485     {
 486         /* Collapse "/./" -> "/" */
 487         p = lpath;
 488         while (*p)
 489         {
 490             if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
 491                 str_move (p, p + 2);
 492             else
 493                 p++;
 494         }
 495     }
 496
 497     if (flags & CANON_PATH_REMSLASHDOTS)
 498     {
 499         /* Remove trailing slashes */
 500         p = lpath + strlen (lpath) - 1;
 501         while (p > lpath && *p == PATH_SEP)
 502         {
 503             if (p >= lpath - (url_delim_len + 1)
 504                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 505                 break;
 506             *p-- = 0;
 507         }
 508
 509         /* Remove leading "./" */
 510         if (lpath[0] == '.' && lpath[1] == PATH_SEP)
 511         {
 512             if (lpath[2] == 0)
 513             {
 514                 lpath[1] = 0;
 515                 return;
 516             }
 517             else
 518             {
 519                 str_move (lpath, lpath + 2);
 520             }
 521         }
 522
 523         /* Remove trailing "/" or "/." */
 524         len = strlen (lpath);
 525         if (len < 2)
 526             return;
 527         if (lpath[len - 1] == PATH_SEP
 528             && (len < url_delim_len
 529                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 530                             url_delim_len) != 0))
 531         {
 532             lpath[len - 1] = '\0';
 533         }
 534         else
 535         {
 536             if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP)
 537             {
 538                 if (len == 2)
 539                 {
 540                     lpath[1] = '\0';
 541                     return;
 542                 }
 543                 else
 544                 {
 545                     lpath[len - 2] = '\0';
 546                 }
 547             }
 548         }
 549     }
 550
 551     if (flags & CANON_PATH_REMDOUBLEDOTS)
 552     {
 553         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 554
 555         /* Collapse "/.." with the previous part of path */
 556         p = lpath;
 557         while (p[0] && p[1] && p[2])
 558         {
 559             if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.') || (p[3] != PATH_SEP && p[3] != 0))
 560             {
 561                 p++;
 562                 continue;
 563             }
 564
 565             /* search for the previous token */
 566             s = p - 1;
 567             if (s >= lpath + url_delim_len - 2
 568                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 569             {
 570                 s -= (url_delim_len - 2);
 571                 while (s >= lpath && *s-- != PATH_SEP);
 572             }
 573
 574             while (s >= lpath)
 575             {
 576                 if (s - url_delim_len > lpath
 577                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 578                 {
 579                     char *vfs_prefix = s - url_delim_len;
 580                     struct vfs_class *vclass;
 581
 582                     while (vfs_prefix > lpath && *--vfs_prefix != PATH_SEP);
 583                     if (*vfs_prefix == PATH_SEP)
 584                         vfs_prefix++;
 585                     *(s - url_delim_len) = '\0';
 586
 587                     vclass = vfs_prefix_to_class (vfs_prefix);
 588                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 589
 590                     if (vclass != NULL)
 591                     {
 592                         struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
 593                         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 594                         {
 595                             s = vfs_prefix;
 596                             continue;
 597                         }
 598                     }
 599                 }
 600
 601                 if (*s == PATH_SEP)
 602                     break;
 603
 604                 s--;
 605             }
 606
 607             s++;
 608
 609             /* If the previous token is "..", we cannot collapse it */
 610             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
 611             {
 612                 p += 3;
 613                 continue;
 614             }
 615
 616             if (p[3] != 0)
 617             {
 618                 if (s == lpath && *s == PATH_SEP)
 619                 {
 620                     /* "/../foo" -> "/foo" */
 621                     str_move (s + 1, p + 4);
 622                 }
 623                 else
 624                 {
 625                     /* "token/../foo" -> "foo" */
 626 #ifdef HAVE_CHARSET
 627                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 628                         && (is_supported_encoding (s + enc_prefix_len)))
 629                         /* special case: remove encoding */
 630                         str_move (s, p + 1);
 631                     else
 632 #endif /* HAVE_CHARSET */
 633                         str_move (s, p + 4);
 634                 }
 635                 p = (s > lpath) ? s - 1 : s;
 636                 continue;
 637             }
 638
 639             /* trailing ".." */
 640             if (s == lpath)
 641             {
 642                 /* "token/.." -> "." */
 643                 if (lpath[0] != PATH_SEP)
 644                 {
 645                     lpath[0] = '.';
 646                 }
 647                 lpath[1] = 0;
 648             }
 649             else
 650             {
 651                 /* "foo/token/.." -> "foo" */
 652                 if (s == lpath + 1)
 653                     s[0] = 0;
 654 #ifdef HAVE_CHARSET
 655                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 656                          && (is_supported_encoding (s + enc_prefix_len)))
 657                 {
 658                     /* special case: remove encoding */
 659                     s[0] = '.';
 660                     s[1] = '.';
 661                     s[2] = '\0';
 662
 663                     /* search for the previous token */
 664                     /* s[-1] == PATH_SEP */
 665                     p = s - 1;
 666                     while (p >= lpath && *p != PATH_SEP)
 667                         p--;
 668
 669                     if (p != NULL)
 670                         continue;
 671                 }
 672 #endif /* HAVE_CHARSET */
 673                 else
 674                 {
 675                     if (s >= lpath + url_delim_len
 676                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 677                         *s = '\0';
 678                     else
 679                         s[-1] = '\0';
 680                 }
 681                 break;
 682             }
 683
 684             break;
 685         }
 686     }
 687 }
 688
 689 /* --------------------------------------------------------------------------------------------- */
 690
 691 void
 692 canonicalize_pathname (char *path)
 693 {
 694     custom_canonicalize_pathname (path, CANON_PATH_ALL);
 695 }
 696
 697 /* --------------------------------------------------------------------------------------------- */
 698
 699 #ifdef HAVE_GET_PROCESS_STATS
 700 int
 701 gettimeofday (struct timeval *tp, void *tzp)
 702 {
 703     return get_process_stats (tp, PS_SELF, 0, 0);
 704 }
 705 #endif /* HAVE_GET_PROCESS_STATS */
 706
 707 /* --------------------------------------------------------------------------------------------- */
 708
 709 #ifndef HAVE_REALPATH
 710 char *
 711 mc_realpath (const char *path, char *resolved_path)
 712 {
 713     char copy_path[PATH_MAX];
 714     char link_path[PATH_MAX];
 715     char got_path[PATH_MAX];
 716     char *new_path = got_path;
 717     char *max_path;
 718     int readlinks = 0;
 719     int n;
 720
 721     /* Make a copy of the source path since we may need to modify it. */
 722     if (strlen (path) >= PATH_MAX - 2)
 723     {
 724         errno = ENAMETOOLONG;
 725         return NULL;
 726     }
 727     strcpy (copy_path, path);
 728     path = copy_path;
 729     max_path = copy_path + PATH_MAX - 2;
 730     /* If it's a relative pathname use getwd for starters. */
 731     if (*path != '/')
 732     {
 733
 734         new_path = g_get_current_dir ();
 735         if (new_path == NULL)
 736         {
 737             strcpy (got_path, "");
 738         }
 739         else
 740         {
 741             g_snprintf (got_path, PATH_MAX, "%s", new_path);
 742             g_free (new_path);
 743             new_path = got_path;
 744         }
 745
 746         new_path += strlen (got_path);
 747         if (new_path[-1] != '/')
 748             *new_path++ = '/';
 749     }
 750     else
 751     {
 752         *new_path++ = '/';
 753         path++;
 754     }
 755     /* Expand each slash-separated pathname component. */
 756     while (*path != '\0')
 757     {
 758         /* Ignore stray "/". */
 759         if (*path == '/')
 760         {
 761             path++;
 762             continue;
 763         }
 764         if (*path == '.')
 765         {
 766             /* Ignore ".". */
 767             if (path[1] == '\0' || path[1] == '/')
 768             {
 769                 path++;
 770                 continue;
 771             }
 772             if (path[1] == '.')
 773             {
 774                 if (path[2] == '\0' || path[2] == '/')
 775                 {
 776                     path += 2;
 777                     /* Ignore ".." at root. */
 778                     if (new_path == got_path + 1)
 779                         continue;
 780                     /* Handle ".." by backing up. */
 781                     while ((--new_path)[-1] != '/');
 782                     continue;
 783                 }
 784             }
 785         }
 786         /* Safely copy the next pathname component. */
 787         while (*path != '\0' && *path != '/')
 788         {
 789             if (path > max_path)
 790             {
 791                 errno = ENAMETOOLONG;
 792                 return NULL;
 793             }
 794             *new_path++ = *path++;
 795         }
 796 #ifdef S_IFLNK
 797         /* Protect against infinite loops. */
 798         if (readlinks++ > MAXSYMLINKS)
 799         {
 800             errno = ELOOP;
 801             return NULL;
 802         }
 803         /* See if latest pathname component is a symlink. */
 804         *new_path = '\0';
 805         n = readlink (got_path, link_path, PATH_MAX - 1);
 806         if (n < 0)
 807         {
 808             /* EINVAL means the file exists but isn't a symlink. */
 809             if (errno != EINVAL)
 810             {
 811                 /* Make sure it's null terminated. */
 812                 *new_path = '\0';
 813                 strcpy (resolved_path, got_path);
 814                 return NULL;
 815             }
 816         }
 817         else
 818         {
 819             /* Note: readlink doesn't add the null byte. */
 820             link_path[n] = '\0';
 821             if (*link_path == '/')
 822                 /* Start over for an absolute symlink. */
 823                 new_path = got_path;
 824             else
 825                 /* Otherwise back up over this component. */
 826                 while (*(--new_path) != '/');
 827             /* Safe sex check. */
 828             if (strlen (path) + n >= PATH_MAX - 2)
 829             {
 830                 errno = ENAMETOOLONG;
 831                 return NULL;
 832             }
 833             /* Insert symlink contents into path. */
 834             strcat (link_path, path);
 835             strcpy (copy_path, link_path);
 836             path = copy_path;
 837         }
 838 #endif /* S_IFLNK */
 839         *new_path++ = '/';
 840     }
 841     /* Delete trailing slash but don't whomp a lone slash. */
 842     if (new_path != got_path + 1 && new_path[-1] == '/')
 843         new_path--;
 844     /* Make sure it's null terminated. */
 845     *new_path = '\0';
 846     strcpy (resolved_path, got_path);
 847     return resolved_path;
 848 }
 849 #endif /* HAVE_REALPATH */
 850
 851 /* --------------------------------------------------------------------------------------------- */
 852 /**
 853  * Return the index of the permissions triplet
 854  *
 855  */
 856
 857 int
 858 get_user_permissions (struct stat *st)
 859 {
 860     static gboolean initialized = FALSE;
 861     static gid_t *groups;
 862     static int ngroups;
 863     static uid_t uid;
 864     int i;
 865
 866     if (!initialized)
 867     {
 868         uid = geteuid ();
 869
 870         ngroups = getgroups (0, NULL);
 871         if (ngroups == -1)
 872             ngroups = 0;        /* ignore errors */
 873
 874         /* allocate space for one element in addition to what
 875          * will be filled by getgroups(). */
 876         groups = g_new (gid_t, ngroups + 1);
 877
 878         if (ngroups != 0)
 879         {
 880             ngroups = getgroups (ngroups, groups);
 881             if (ngroups == -1)
 882                 ngroups = 0;    /* ignore errors */
 883         }
 884
 885         /* getgroups() may or may not return the effective group ID,
 886          * so we always include it at the end of the list. */
 887         groups[ngroups++] = getegid ();
 888
 889         initialized = TRUE;
 890     }
 891
 892     if (st->st_uid == uid || uid == 0)
 893         return 0;
 894
 895     for (i = 0; i < ngroups; i++)
 896     {
 897         if (st->st_gid == groups[i])
 898             return 1;
 899     }
 900
 901     return 2;
 902 }
 903
 904 /* --------------------------------------------------------------------------------------------- */
 905 /**
 906  * Build filename from arguments.
 907  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
 908  */
 909
 910 char *
 911 mc_build_filenamev (const char *first_element, va_list args)
 912 {
 913     gboolean absolute;
 914     const char *element = first_element;
 915     GString *path;
 916     char *ret;
 917
 918     if (element == NULL)
 919         return NULL;
 920
 921     path = g_string_new ("");
 922
 923     absolute = (*first_element != '\0' && *first_element == PATH_SEP);
 924
 925     do
 926     {
 927         if (*element == '\0')
 928             element = va_arg (args, char *);
 929         else
 930         {
 931             char *tmp_element;
 932             size_t len;
 933             const char *start;
 934
 935             tmp_element = g_strdup (element);
 936
 937             element = va_arg (args, char *);
 938
 939             canonicalize_pathname (tmp_element);
 940             len = strlen (tmp_element);
 941             start = (tmp_element[0] == PATH_SEP) ? tmp_element + 1 : tmp_element;
 942
 943             g_string_append (path, start);
 944             if (tmp_element[len - 1] != PATH_SEP && element != NULL)
 945                 g_string_append_c (path, PATH_SEP);
 946
 947             g_free (tmp_element);
 948         }
 949     }
 950     while (element != NULL);
 951
 952     if (absolute)
 953         g_string_prepend_c (path, PATH_SEP);
 954
 955     ret = g_string_free (path, FALSE);
 956     canonicalize_pathname (ret);
 957
 958     return ret;
 959 }
 960
 961 /* --------------------------------------------------------------------------------------------- */
 962 /**
 963  * Build filename from arguments.
 964  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
 965  */
 966
 967 char *
 968 mc_build_filename (const char *first_element, ...)
 969 {
 970     va_list args;
 971     char *ret;
 972
 973     if (first_element == NULL)
 974         return NULL;
 975
 976     va_start (args, first_element);
 977     ret = mc_build_filenamev (first_element, args);
 978     va_end (args);
 979     return ret;
 980 }
 981
 982 /* --------------------------------------------------------------------------------------------- */