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  * Return the directory where mc should keep its temporary files.
 330  * This directory is (in Bourne shell terms) "${TMPDIR=/tmp}/mc-$USER"
 331  * When called the first time, the directory is created if needed.
 332  * The first call should be done early, since we are using fprintf()
 333  * and not message() to report possible problems.
 334  */
 335
 336 const char *
 337 mc_tmpdir (void)
 338 {
 339     static char buffer[64];
 340     static const char *tmpdir = NULL;
 341     const char *sys_tmp;
 342     struct passwd *pwd;
 343     struct stat st;
 344     const char *error = NULL;
 345
 346     /* Check if already correctly initialized */
 347     if (tmpdir && lstat (tmpdir, &st) == 0 && S_ISDIR (st.st_mode) &&
 348         st.st_uid == getuid () && (st.st_mode & 0777) == 0700)
 349         return tmpdir;
 350
 351     sys_tmp = getenv ("TMPDIR");
 352     if (!sys_tmp || sys_tmp[0] != '/')
 353     {
 354         sys_tmp = TMPDIR_DEFAULT;
 355     }
 356
 357     pwd = getpwuid (getuid ());
 358
 359     if (pwd)
 360         g_snprintf (buffer, sizeof (buffer), "%s/mc-%s", sys_tmp, pwd->pw_name);
 361     else
 362         g_snprintf (buffer, sizeof (buffer), "%s/mc-%lu", sys_tmp, (unsigned long) getuid ());
 363
 364     canonicalize_pathname (buffer);
 365
 366     if (lstat (buffer, &st) == 0)
 367     {
 368         /* Sanity check for existing directory */
 369         if (!S_ISDIR (st.st_mode))
 370             error = _("%s is not a directory\n");
 371         else if (st.st_uid != getuid ())
 372             error = _("Directory %s is not owned by you\n");
 373         else if (((st.st_mode & 0777) != 0700) && (chmod (buffer, 0700) != 0))
 374             error = _("Cannot set correct permissions for directory %s\n");
 375     }
 376     else
 377     {
 378         /* Need to create directory */
 379         if (mkdir (buffer, S_IRWXU) != 0)
 380         {
 381             fprintf (stderr,
 382                      _("Cannot create temporary directory %s: %s\n"),
 383                      buffer, unix_error_string (errno));
 384             error = "";
 385         }
 386     }
 387
 388     if (error != NULL)
 389     {
 390         int test_fd;
 391         char *test_fn, *fallback_prefix;
 392         int fallback_ok = 0;
 393
 394         if (*error)
 395             fprintf (stderr, error, buffer);
 396
 397         /* Test if sys_tmp is suitable for temporary files */
 398         fallback_prefix = g_strdup_printf ("%s/mctest", sys_tmp);
 399         test_fd = mc_mkstemps (&test_fn, fallback_prefix, NULL);
 400         g_free (fallback_prefix);
 401         if (test_fd != -1)
 402         {
 403             close (test_fd);
 404             test_fd = open (test_fn, O_RDONLY);
 405             if (test_fd != -1)
 406             {
 407                 close (test_fd);
 408                 unlink (test_fn);
 409                 fallback_ok = 1;
 410             }
 411         }
 412
 413         if (fallback_ok)
 414         {
 415             fprintf (stderr, _("Temporary files will be created in %s\n"), sys_tmp);
 416             g_snprintf (buffer, sizeof (buffer), "%s", sys_tmp);
 417             error = NULL;
 418         }
 419         else
 420         {
 421             fprintf (stderr, _("Temporary files will not be created\n"));
 422             g_snprintf (buffer, sizeof (buffer), "%s", "/dev/null/");
 423         }
 424
 425         fprintf (stderr, "%s\n", _("Press any key to continue..."));
 426         getc (stdin);
 427     }
 428
 429     tmpdir = buffer;
 430
 431     if (!error)
 432         g_setenv ("MC_TMPDIR", tmpdir, TRUE);
 433
 434     return tmpdir;
 435 }
 436
 437 /* --------------------------------------------------------------------------------------------- */
 438 /**
 439  * Creates a pipe to hold standard error for a later analysis.
 440  * The pipe can hold 4096 bytes. Make sure no more is written
 441  * or a deadlock might occur.
 442  */
 443
 444 void
 445 open_error_pipe (void)
 446 {
 447     if (pipe (error_pipe) < 0)
 448     {
 449         message (D_NORMAL, _("Warning"), _("Pipe failed"));
 450     }
 451     old_error = dup (2);
 452     if (old_error < 0 || close (2) || dup (error_pipe[1]) != 2)
 453     {
 454         message (D_NORMAL, _("Warning"), _("Dup failed"));
 455
 456         close (error_pipe[0]);
 457         error_pipe[0] = -1;
 458     }
 459     else
 460     {
 461         /*
 462          * Settng stderr in nonblocking mode as we close it earlier, than
 463          * program stops. We try to read some error at program startup,
 464          * but we should not block on it.
 465          *
 466          * TODO: make piped stdin/stderr poll()/select()able to get rid
 467          * of following hack.
 468          */
 469         int fd_flags;
 470         fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
 471         if (fd_flags != -1)
 472         {
 473             fd_flags |= O_NONBLOCK;
 474             if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
 475             {
 476                 /* TODO: handle it somehow */
 477             }
 478         }
 479     }
 480     /* we never write there */
 481     close (error_pipe[1]);
 482     error_pipe[1] = -1;
 483 }
 484
 485 /* --------------------------------------------------------------------------------------------- */
 486 /**
 487  * Returns true if an error was displayed
 488  * error: -1 - ignore errors, 0 - display warning, 1 - display error
 489  * text is prepended to the error message from the pipe
 490  */
 491
 492 int
 493 close_error_pipe (int error, const char *text)
 494 {
 495     const char *title;
 496     char msg[MAX_PIPE_SIZE];
 497     int len = 0;
 498
 499     /* already closed */
 500     if (error_pipe[0] == -1)
 501         return 0;
 502
 503     if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
 504         title = MSG_ERROR;
 505     else
 506         title = _("Warning");
 507     if (old_error >= 0)
 508     {
 509         if (dup2 (old_error, 2) == -1)
 510         {
 511             if (error < 0)
 512                 error = D_ERROR;
 513
 514             message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
 515             return 1;
 516         }
 517         close (old_error);
 518         len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
 519
 520         if (len >= 0)
 521             msg[len] = 0;
 522         close (error_pipe[0]);
 523         error_pipe[0] = -1;
 524     }
 525     if (error < 0)
 526         return 0;               /* Just ignore error message */
 527     if (text == NULL)
 528     {
 529         if (len <= 0)
 530             return 0;           /* Nothing to show */
 531
 532         /* Show message from pipe */
 533         message (error, title, "%s", msg);
 534     }
 535     else
 536     {
 537         /* Show given text and possible message from pipe */
 538         message (error, title, "%s\n%s", text, msg);
 539     }
 540     return 1;
 541 }
 542
 543 /* --------------------------------------------------------------------------------------------- */
 544 /**
 545  * Canonicalize path, and return a new path.  Do everything in place.
 546  * The new path differs from path in:
 547  *      Multiple `/'s are collapsed to a single `/'.
 548  *      Leading `./'s and trailing `/.'s are removed.
 549  *      Trailing `/'s are removed.
 550  *      Non-leading `../'s and trailing `..'s are handled by removing
 551  *      portions of the path.
 552  * Well formed UNC paths are modified only in the local part.
 553  */
 554
 555 void
 556 custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
 557 {
 558     char *p, *s;
 559     size_t len;
 560     char *lpath = path;         /* path without leading UNC part */
 561     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 562
 563     /* Detect and preserve UNC paths: //server/... */
 564     if ((flags & CANON_PATH_GUARDUNC) && path[0] == PATH_SEP && path[1] == PATH_SEP)
 565     {
 566         p = path + 2;
 567         while (p[0] && p[0] != '/')
 568             p++;
 569         if (p[0] == '/' && p > path + 2)
 570             lpath = p;
 571     }
 572
 573     if (!lpath[0] || !lpath[1])
 574         return;
 575
 576     if (flags & CANON_PATH_JOINSLASHES)
 577     {
 578         /* Collapse multiple slashes */
 579         p = lpath;
 580         while (*p)
 581         {
 582             if (p[0] == PATH_SEP && p[1] == PATH_SEP && (p == lpath || *(p - 1) != ':'))
 583             {
 584                 s = p + 1;
 585                 while (*(++s) == PATH_SEP);
 586                 str_move (p + 1, s);
 587             }
 588             p++;
 589         }
 590     }
 591
 592     if (flags & CANON_PATH_JOINSLASHES)
 593     {
 594         /* Collapse "/./" -> "/" */
 595         p = lpath;
 596         while (*p)
 597         {
 598             if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
 599                 str_move (p, p + 2);
 600             else
 601                 p++;
 602         }
 603     }
 604
 605     if (flags & CANON_PATH_REMSLASHDOTS)
 606     {
 607         /* Remove trailing slashes */
 608         p = lpath + strlen (lpath) - 1;
 609         while (p > lpath && *p == PATH_SEP)
 610         {
 611             if (p >= lpath - (url_delim_len + 1)
 612                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 613                 break;
 614             *p-- = 0;
 615         }
 616
 617         /* Remove leading "./" */
 618         if (lpath[0] == '.' && lpath[1] == PATH_SEP)
 619         {
 620             if (lpath[2] == 0)
 621             {
 622                 lpath[1] = 0;
 623                 return;
 624             }
 625             else
 626             {
 627                 str_move (lpath, lpath + 2);
 628             }
 629         }
 630
 631         /* Remove trailing "/" or "/." */
 632         len = strlen (lpath);
 633         if (len < 2)
 634             return;
 635         if (lpath[len - 1] == PATH_SEP
 636             && (len < url_delim_len
 637                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 638                             url_delim_len) != 0))
 639         {
 640             lpath[len - 1] = '\0';
 641         }
 642         else
 643         {
 644             if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP)
 645             {
 646                 if (len == 2)
 647                 {
 648                     lpath[1] = '\0';
 649                     return;
 650                 }
 651                 else
 652                 {
 653                     lpath[len - 2] = '\0';
 654                 }
 655             }
 656         }
 657     }
 658
 659     if (flags & CANON_PATH_REMDOUBLEDOTS)
 660     {
 661         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 662
 663         /* Collapse "/.." with the previous part of path */
 664         p = lpath;
 665         while (p[0] && p[1] && p[2])
 666         {
 667             if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.') || (p[3] != PATH_SEP && p[3] != 0))
 668             {
 669                 p++;
 670                 continue;
 671             }
 672
 673             /* search for the previous token */
 674             s = p - 1;
 675             if (s >= lpath + url_delim_len - 2
 676                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 677             {
 678                 s -= (url_delim_len - 2);
 679                 while (s >= lpath && *s-- != PATH_SEP);
 680             }
 681
 682             while (s >= lpath)
 683             {
 684                 if (s - url_delim_len > lpath
 685                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 686                 {
 687                     char *vfs_prefix = s - url_delim_len;
 688                     struct vfs_class *vclass;
 689
 690                     while (vfs_prefix > lpath && *--vfs_prefix != PATH_SEP);
 691                     if (*vfs_prefix == PATH_SEP)
 692                         vfs_prefix++;
 693                     *(s - url_delim_len) = '\0';
 694
 695                     vclass = vfs_prefix_to_class (vfs_prefix);
 696                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 697
 698                     if (vclass != NULL)
 699                     {
 700                         struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
 701                         if (sub != NULL && sub->flags & VFS_S_REMOTE)
 702                         {
 703                             s = vfs_prefix;
 704                             continue;
 705                         }
 706                     }
 707                 }
 708
 709                 if (*s == PATH_SEP)
 710                     break;
 711
 712                 s--;
 713             }
 714
 715             s++;
 716
 717             /* If the previous token is "..", we cannot collapse it */
 718             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
 719             {
 720                 p += 3;
 721                 continue;
 722             }
 723
 724             if (p[3] != 0)
 725             {
 726                 if (s == lpath && *s == PATH_SEP)
 727                 {
 728                     /* "/../foo" -> "/foo" */
 729                     str_move (s + 1, p + 4);
 730                 }
 731                 else
 732                 {
 733                     /* "token/../foo" -> "foo" */
 734 #if HAVE_CHARSET
 735                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 736                         && (is_supported_encoding (s + enc_prefix_len)))
 737                         /* special case: remove encoding */
 738                         str_move (s, p + 1);
 739                     else
 740 #endif /* HAVE_CHARSET */
 741                         str_move (s, p + 4);
 742                 }
 743                 p = (s > lpath) ? s - 1 : s;
 744                 continue;
 745             }
 746
 747             /* trailing ".." */
 748             if (s == lpath)
 749             {
 750                 /* "token/.." -> "." */
 751                 if (lpath[0] != PATH_SEP)
 752                 {
 753                     lpath[0] = '.';
 754                 }
 755                 lpath[1] = 0;
 756             }
 757             else
 758             {
 759                 /* "foo/token/.." -> "foo" */
 760                 if (s == lpath + 1)
 761                     s[0] = 0;
 762 #if HAVE_CHARSET
 763                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 764                          && (is_supported_encoding (s + enc_prefix_len)))
 765                 {
 766                     /* special case: remove encoding */
 767                     s[0] = '.';
 768                     s[1] = '.';
 769                     s[2] = '\0';
 770
 771                     /* search for the previous token */
 772                     /* s[-1] == PATH_SEP */
 773                     p = s - 1;
 774                     while (p >= lpath && *p != PATH_SEP)
 775                         p--;
 776
 777                     if (p != NULL)
 778                         continue;
 779                 }
 780 #endif /* HAVE_CHARSET */
 781                 else
 782                 {
 783                     if (s >= lpath + url_delim_len
 784                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 785                         *s = '\0';
 786                     else
 787                         s[-1] = '\0';
 788                 }
 789                 break;
 790             }
 791
 792             break;
 793         }
 794     }
 795 }
 796
 797 /* --------------------------------------------------------------------------------------------- */
 798
 799 void
 800 canonicalize_pathname (char *path)
 801 {
 802     custom_canonicalize_pathname (path, CANON_PATH_ALL);
 803 }
 804
 805 /* --------------------------------------------------------------------------------------------- */
 806
 807 #ifdef HAVE_GET_PROCESS_STATS
 808 int
 809 gettimeofday (struct timeval *tp, void *tzp)
 810 {
 811     return get_process_stats (tp, PS_SELF, 0, 0);
 812 }
 813 #endif /* HAVE_GET_PROCESS_STATS */
 814
 815 /* --------------------------------------------------------------------------------------------- */
 816
 817 #ifndef HAVE_REALPATH
 818 char *
 819 mc_realpath (const char *path, char *resolved_path)
 820 {
 821     char copy_path[PATH_MAX];
 822     char link_path[PATH_MAX];
 823     char got_path[PATH_MAX];
 824     char *new_path = got_path;
 825     char *max_path;
 826     int readlinks = 0;
 827     int n;
 828
 829     /* Make a copy of the source path since we may need to modify it. */
 830     if (strlen (path) >= PATH_MAX - 2)
 831     {
 832         errno = ENAMETOOLONG;
 833         return NULL;
 834     }
 835     strcpy (copy_path, path);
 836     path = copy_path;
 837     max_path = copy_path + PATH_MAX - 2;
 838     /* If it's a relative pathname use getwd for starters. */
 839     if (*path != '/')
 840     {
 841
 842         new_path = g_get_current_dir ();
 843         if (new_path == NULL)
 844         {
 845             strcpy (got_path, "");
 846         }
 847         else
 848         {
 849             g_snprintf (got_path, PATH_MAX, "%s", new_path);
 850             g_free (new_path);
 851             new_path = got_path;
 852         }
 853
 854         new_path += strlen (got_path);
 855         if (new_path[-1] != '/')
 856             *new_path++ = '/';
 857     }
 858     else
 859     {
 860         *new_path++ = '/';
 861         path++;
 862     }
 863     /* Expand each slash-separated pathname component. */
 864     while (*path != '\0')
 865     {
 866         /* Ignore stray "/". */
 867         if (*path == '/')
 868         {
 869             path++;
 870             continue;
 871         }
 872         if (*path == '.')
 873         {
 874             /* Ignore ".". */
 875             if (path[1] == '\0' || path[1] == '/')
 876             {
 877                 path++;
 878                 continue;
 879             }
 880             if (path[1] == '.')
 881             {
 882                 if (path[2] == '\0' || path[2] == '/')
 883                 {
 884                     path += 2;
 885                     /* Ignore ".." at root. */
 886                     if (new_path == got_path + 1)
 887                         continue;
 888                     /* Handle ".." by backing up. */
 889                     while ((--new_path)[-1] != '/');
 890                     continue;
 891                 }
 892             }
 893         }
 894         /* Safely copy the next pathname component. */
 895         while (*path != '\0' && *path != '/')
 896         {
 897             if (path > max_path)
 898             {
 899                 errno = ENAMETOOLONG;
 900                 return NULL;
 901             }
 902             *new_path++ = *path++;
 903         }
 904 #ifdef S_IFLNK
 905         /* Protect against infinite loops. */
 906         if (readlinks++ > MAXSYMLINKS)
 907         {
 908             errno = ELOOP;
 909             return NULL;
 910         }
 911         /* See if latest pathname component is a symlink. */
 912         *new_path = '\0';
 913         n = readlink (got_path, link_path, PATH_MAX - 1);
 914         if (n < 0)
 915         {
 916             /* EINVAL means the file exists but isn't a symlink. */
 917             if (errno != EINVAL)
 918             {
 919                 /* Make sure it's null terminated. */
 920                 *new_path = '\0';
 921                 strcpy (resolved_path, got_path);
 922                 return NULL;
 923             }
 924         }
 925         else
 926         {
 927             /* Note: readlink doesn't add the null byte. */
 928             link_path[n] = '\0';
 929             if (*link_path == '/')
 930                 /* Start over for an absolute symlink. */
 931                 new_path = got_path;
 932             else
 933                 /* Otherwise back up over this component. */
 934                 while (*(--new_path) != '/');
 935             /* Safe sex check. */
 936             if (strlen (path) + n >= PATH_MAX - 2)
 937             {
 938                 errno = ENAMETOOLONG;
 939                 return NULL;
 940             }
 941             /* Insert symlink contents into path. */
 942             strcat (link_path, path);
 943             strcpy (copy_path, link_path);
 944             path = copy_path;
 945         }
 946 #endif /* S_IFLNK */
 947         *new_path++ = '/';
 948     }
 949     /* Delete trailing slash but don't whomp a lone slash. */
 950     if (new_path != got_path + 1 && new_path[-1] == '/')
 951         new_path--;
 952     /* Make sure it's null terminated. */
 953     *new_path = '\0';
 954     strcpy (resolved_path, got_path);
 955     return resolved_path;
 956 }
 957 #endif /* HAVE_REALPATH */
 958
 959 /* --------------------------------------------------------------------------------------------- */
 960 /**
 961  * Return the index of the permissions triplet
 962  *
 963  */
 964
 965 int
 966 get_user_permissions (struct stat *st)
 967 {
 968     static gboolean initialized = FALSE;
 969     static gid_t *groups;
 970     static int ngroups;
 971     static uid_t uid;
 972     int i;
 973
 974     if (!initialized)
 975     {
 976         uid = geteuid ();
 977
 978         ngroups = getgroups (0, NULL);
 979         if (ngroups == -1)
 980             ngroups = 0;        /* ignore errors */
 981
 982         /* allocate space for one element in addition to what
 983          * will be filled by getgroups(). */
 984         groups = g_new (gid_t, ngroups + 1);
 985
 986         if (ngroups != 0)
 987         {
 988             ngroups = getgroups (ngroups, groups);
 989             if (ngroups == -1)
 990                 ngroups = 0;    /* ignore errors */
 991         }
 992
 993         /* getgroups() may or may not return the effective group ID,
 994          * so we always include it at the end of the list. */
 995         groups[ngroups++] = getegid ();
 996
 997         initialized = TRUE;
 998     }
 999
1000     if (st->st_uid == uid || uid == 0)
1001         return 0;
1002
1003     for (i = 0; i < ngroups; i++)
1004     {
1005         if (st->st_gid == groups[i])
1006             return 1;
1007     }
1008
1009     return 2;
1010 }
1011
1012 /* --------------------------------------------------------------------------------------------- */
1013 /**
1014  * Build filename from arguments.
1015  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1016  */
1017
1018 char *
1019 mc_build_filename (const char *first_element, ...)
1020 {
1021     gboolean absolute;
1022     va_list args;
1023     const char *element = first_element;
1024     GString *path;
1025     char *ret;
1026
1027     if (element == NULL)
1028         return NULL;
1029
1030     path = g_string_new ("");
1031     va_start (args, first_element);
1032
1033     absolute = (*first_element != '\0' && *first_element == PATH_SEP);
1034
1035     do
1036     {
1037         if (*element == '\0')
1038             element = va_arg (args, char *);
1039         else
1040         {
1041             char *tmp_element;
1042             size_t len;
1043             const char *start;
1044
1045             tmp_element = g_strdup (element);
1046
1047             element = va_arg (args, char *);
1048
1049             canonicalize_pathname (tmp_element);
1050             len = strlen (tmp_element);
1051             start = (tmp_element[0] == PATH_SEP) ? tmp_element + 1 : tmp_element;
1052
1053             g_string_append (path, start);
1054             if (tmp_element[len - 1] != PATH_SEP && element != NULL)
1055                 g_string_append_c (path, PATH_SEP);
1056
1057             g_free (tmp_element);
1058         }
1059     }
1060     while (element != NULL);
1061
1062     va_end (args);
1063
1064     if (absolute)
1065         g_string_prepend_c (path, PATH_SEP);
1066
1067     ret = g_string_free (path, FALSE);
1068     canonicalize_pathname (ret);
1069
1070     return ret;
1071 }
1072
1073 /* --------------------------------------------------------------------------------------------- */