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