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