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