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