lib/utilunix.c

   1 /*
   2    Various utilities - Unix variants
   3
   4    Copyright (C) 1994-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Miguel de Icaza, 1994, 1995, 1996
   9    Janne Kukonlehto, 1994, 1995, 1996
  10    Dugan Porter, 1994, 1995, 1996
  11    Jakub Jelinek, 1994, 1995, 1996
  12    Mauricio Plaza, 1994, 1995, 1996
  13    Andrew Borodin <aborodin@vmail.ru> 2010-2024
  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 #ifdef HAVE_SYS_PARAM_H
  49 #include <sys/param.h>
  50 #endif
  51 #include <sys/types.h>
  52 #include <sys/stat.h>
  53 #ifdef HAVE_SYS_SELECT_H
  54 #include <sys/select.h>
  55 #endif
  56 #include <sys/wait.h>
  57 #include <pwd.h>
  58 #include <grp.h>
  59
  60 #include "lib/global.h"
  61
  62 #include "lib/unixcompat.h"
  63 #include "lib/vfs/vfs.h"        /* VFS_ENCODING_PREFIX */
  64 #include "lib/strutil.h"        /* str_move(), str_tokenize() */
  65 #include "lib/util.h"
  66 #include "lib/widget.h"         /* message() */
  67 #include "lib/vfs/xdirentry.h"
  68
  69 #ifdef HAVE_CHARSET
  70 #include "lib/charsets.h"
  71 #endif
  72
  73 #include "utilunix.h"
  74
  75 /*** global variables ****************************************************************************/
  76
  77 struct sigaction startup_handler;
  78
  79 /*** file scope macro definitions ****************************************************************/
  80
  81 #define UID_CACHE_SIZE 200
  82 #define GID_CACHE_SIZE 30
  83
  84 /*** file scope type declarations ****************************************************************/
  85
  86 typedef struct
  87 {
  88     int index;
  89     char *string;
  90 } int_cache;
  91
  92 typedef enum
  93 {
  94     FORK_ERROR = -1,
  95     FORK_CHILD,
  96     FORK_PARENT,
  97 } my_fork_state_t;
  98
  99 typedef struct
 100 {
 101     struct sigaction intr;
 102     struct sigaction quit;
 103     struct sigaction stop;
 104 } my_system_sigactions_t;
 105
 106 /*** forward declarations (file scope functions) *************************************************/
 107
 108 /*** file scope variables ************************************************************************/
 109
 110 static int_cache uid_cache[UID_CACHE_SIZE];
 111 static int_cache gid_cache[GID_CACHE_SIZE];
 112
 113 /* --------------------------------------------------------------------------------------------- */
 114 /*** file scope functions ************************************************************************/
 115 /* --------------------------------------------------------------------------------------------- */
 116
 117 static char *
 118 i_cache_match (int id, int_cache * cache, int size)
 119 {
 120     int i;
 121
 122     for (i = 0; i < size; i++)
 123         if (cache[i].index == id)
 124             return cache[i].string;
 125     return 0;
 126 }
 127
 128 /* --------------------------------------------------------------------------------------------- */
 129
 130 static void
 131 i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
 132 {
 133     g_free (cache[*last].string);
 134     cache[*last].string = g_strdup (text);
 135     cache[*last].index = id;
 136     *last = ((*last) + 1) % size;
 137 }
 138
 139 /* --------------------------------------------------------------------------------------------- */
 140
 141 static my_fork_state_t
 142 my_fork (void)
 143 {
 144     pid_t pid;
 145
 146     pid = fork ();
 147
 148     if (pid < 0)
 149     {
 150         fprintf (stderr, "\n\nfork () = -1\n");
 151         return FORK_ERROR;
 152     }
 153
 154     if (pid == 0)
 155         return FORK_CHILD;
 156
 157     while (TRUE)
 158     {
 159         int status = 0;
 160
 161         if (waitpid (pid, &status, 0) > 0)
 162             return WEXITSTATUS (status) == 0 ? FORK_PARENT : FORK_ERROR;
 163
 164         if (errno != EINTR)
 165             return FORK_ERROR;
 166     }
 167 }
 168
 169 /* --------------------------------------------------------------------------------------------- */
 170
 171 static void
 172 my_system__save_sigaction_handlers (my_system_sigactions_t * sigactions)
 173 {
 174     struct sigaction ignore;
 175
 176     memset (&ignore, 0, sizeof (ignore));
 177     ignore.sa_handler = SIG_IGN;
 178     sigemptyset (&ignore.sa_mask);
 179
 180     sigaction (SIGINT, &ignore, &sigactions->intr);
 181     sigaction (SIGQUIT, &ignore, &sigactions->quit);
 182
 183     /* Restore the original SIGTSTP handler, we don't want ncurses' */
 184     /* handler messing the screen after the SIGCONT */
 185     sigaction (SIGTSTP, &startup_handler, &sigactions->stop);
 186 }
 187
 188 /* --------------------------------------------------------------------------------------------- */
 189
 190 static void
 191 my_system__restore_sigaction_handlers (my_system_sigactions_t * sigactions)
 192 {
 193     sigaction (SIGINT, &sigactions->intr, NULL);
 194     sigaction (SIGQUIT, &sigactions->quit, NULL);
 195     sigaction (SIGTSTP, &sigactions->stop, NULL);
 196 }
 197
 198 /* --------------------------------------------------------------------------------------------- */
 199
 200 static GPtrArray *
 201 my_system_make_arg_array (int flags, const char *shell)
 202 {
 203     GPtrArray *args_array;
 204
 205     if ((flags & EXECUTE_AS_SHELL) != 0)
 206     {
 207         args_array = g_ptr_array_new ();
 208         g_ptr_array_add (args_array, (gpointer) shell);
 209         g_ptr_array_add (args_array, (gpointer) "-c");
 210     }
 211     else if (shell == NULL || *shell == '\0')
 212     {
 213         args_array = g_ptr_array_new ();
 214         g_ptr_array_add (args_array, NULL);
 215     }
 216     else
 217         args_array = str_tokenize (shell);
 218
 219     return args_array;
 220 }
 221
 222 /* --------------------------------------------------------------------------------------------- */
 223
 224 static void
 225 mc_pread_stream (mc_pipe_stream_t * ps, const fd_set * fds)
 226 {
 227     size_t buf_len;
 228     ssize_t read_len;
 229
 230     if (!FD_ISSET (ps->fd, fds))
 231     {
 232         ps->len = MC_PIPE_STREAM_UNREAD;
 233         return;
 234     }
 235
 236     buf_len = (size_t) ps->len;
 237
 238     if (buf_len >= MC_PIPE_BUFSIZE)
 239         buf_len = ps->null_term ? MC_PIPE_BUFSIZE - 1 : MC_PIPE_BUFSIZE;
 240
 241     do
 242     {
 243         read_len = read (ps->fd, ps->buf, buf_len);
 244     }
 245     while (read_len < 0 && errno == EINTR);
 246
 247     if (read_len < 0)
 248     {
 249         /* reading error */
 250         ps->len = MC_PIPE_ERROR_READ;
 251         ps->error = errno;
 252     }
 253     else if (read_len == 0)
 254         /* EOF */
 255         ps->len = MC_PIPE_STREAM_EOF;
 256     else
 257     {
 258         /* success */
 259         ps->len = read_len;
 260
 261         if (ps->null_term)
 262             ps->buf[(size_t) ps->len] = '\0';
 263     }
 264
 265     ps->pos = 0;
 266 }
 267
 268 /* --------------------------------------------------------------------------------------------- */
 269 /*** public functions ****************************************************************************/
 270 /* --------------------------------------------------------------------------------------------- */
 271
 272 const char *
 273 get_owner (uid_t uid)
 274 {
 275     struct passwd *pwd;
 276     char *name;
 277     static uid_t uid_last;
 278
 279     name = i_cache_match ((int) uid, uid_cache, UID_CACHE_SIZE);
 280     if (name != NULL)
 281         return name;
 282
 283     pwd = getpwuid (uid);
 284     if (pwd != NULL)
 285     {
 286         i_cache_add ((int) uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, (int *) &uid_last);
 287         return pwd->pw_name;
 288     }
 289     else
 290     {
 291         static char ibuf[10];
 292
 293         g_snprintf (ibuf, sizeof (ibuf), "%d", (int) uid);
 294         return ibuf;
 295     }
 296 }
 297
 298 /* --------------------------------------------------------------------------------------------- */
 299
 300 const char *
 301 get_group (gid_t gid)
 302 {
 303     struct group *grp;
 304     char *name;
 305     static gid_t gid_last;
 306
 307     name = i_cache_match ((int) gid, gid_cache, GID_CACHE_SIZE);
 308     if (name != NULL)
 309         return name;
 310
 311     grp = getgrgid (gid);
 312     if (grp != NULL)
 313     {
 314         i_cache_add ((int) gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, (int *) &gid_last);
 315         return grp->gr_name;
 316     }
 317     else
 318     {
 319         static char gbuf[10];
 320
 321         g_snprintf (gbuf, sizeof (gbuf), "%d", (int) gid);
 322         return gbuf;
 323     }
 324 }
 325
 326 /* --------------------------------------------------------------------------------------------- */
 327 /* Since ncurses uses a handler that automatically refreshes the */
 328 /* screen after a SIGCONT, and we don't want this behavior when */
 329 /* spawning a child, we save the original handler here */
 330
 331 void
 332 save_stop_handler (void)
 333 {
 334     sigaction (SIGTSTP, NULL, &startup_handler);
 335 }
 336
 337 /* --------------------------------------------------------------------------------------------- */
 338 /**
 339  * Wrapper for _exit() system call.
 340  * The _exit() function has gcc's attribute 'noreturn', and this is reason why we can't
 341  * mock the call.
 342  *
 343  * @param status exit code
 344  */
 345
 346 void
 347 /* __attribute__ ((noreturn)) */
 348 my_exit (int status)
 349 {
 350     _exit (status);
 351 }
 352
 353 /* --------------------------------------------------------------------------------------------- */
 354 /**
 355  * Call external programs.
 356  *
 357  * @parameter flags   addition conditions for running external programs.
 358  * @parameter shell   shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 359  *                    Shell (or command) will be found in paths described in PATH variable
 360  *                    (if shell parameter doesn't begin from path delimiter)
 361  * @parameter command Command for shell (or first parameter for command, if flags contain EXECUTE_AS_SHELL)
 362  * @return 0 if successful, -1 otherwise
 363  */
 364
 365 int
 366 my_system (int flags, const char *shell, const char *command)
 367 {
 368     return my_systeml (flags, shell, command, NULL);
 369 }
 370
 371 /* --------------------------------------------------------------------------------------------- */
 372 /**
 373  * Call external programs with various parameters number.
 374  *
 375  * @parameter flags addition conditions for running external programs.
 376  * @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 377  *                  Shell (or command) will be found in paths described in PATH variable
 378  *                  (if shell parameter doesn't begin from path delimiter)
 379  * @parameter ...   Command for shell with addition parameters for shell
 380  *                  (or parameters for command, if flags contain EXECUTE_AS_SHELL).
 381  *                  Should be NULL terminated.
 382  * @return 0 if successful, -1 otherwise
 383  */
 384
 385 int
 386 my_systeml (int flags, const char *shell, ...)
 387 {
 388     GPtrArray *args_array;
 389     int status = 0;
 390     va_list vargs;
 391     char *one_arg;
 392
 393     args_array = g_ptr_array_new ();
 394
 395     va_start (vargs, shell);
 396     while ((one_arg = va_arg (vargs, char *)) != NULL)
 397           g_ptr_array_add (args_array, one_arg);
 398     va_end (vargs);
 399
 400     g_ptr_array_add (args_array, NULL);
 401     status = my_systemv_flags (flags, shell, (char *const *) args_array->pdata);
 402
 403     g_ptr_array_free (args_array, TRUE);
 404
 405     return status;
 406 }
 407
 408 /* --------------------------------------------------------------------------------------------- */
 409 /**
 410  * Call external programs with array of strings as parameters.
 411  *
 412  * @parameter command command to run. Command will be found in paths described in PATH variable
 413  *                    (if command parameter doesn't begin from path delimiter)
 414  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 415  * @return 0 if successful, -1 otherwise
 416  */
 417
 418 int
 419 my_systemv (const char *command, char *const argv[])
 420 {
 421     my_fork_state_t fork_state;
 422     int status = 0;
 423     my_system_sigactions_t sigactions;
 424
 425     my_system__save_sigaction_handlers (&sigactions);
 426
 427     fork_state = my_fork ();
 428     switch (fork_state)
 429     {
 430     case FORK_ERROR:
 431         status = -1;
 432         break;
 433     case FORK_CHILD:
 434         {
 435             signal (SIGINT, SIG_DFL);
 436             signal (SIGQUIT, SIG_DFL);
 437             signal (SIGTSTP, SIG_DFL);
 438             signal (SIGCHLD, SIG_DFL);
 439
 440             execvp (command, argv);
 441             my_exit (127);      /* Exec error */
 442         }
 443         MC_FALLTHROUGH;
 444         /* no break here, or unreachable-code warning by no returning my_exit() */
 445     default:
 446         status = 0;
 447         break;
 448     }
 449     my_system__restore_sigaction_handlers (&sigactions);
 450
 451     return status;
 452 }
 453
 454 /* --------------------------------------------------------------------------------------------- */
 455 /**
 456  * Call external programs with flags and with array of strings as parameters.
 457  *
 458  * @parameter flags   addition conditions for running external programs.
 459  * @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
 460  *                    Shell (or command) will be found in paths described in PATH variable
 461  *                    (if shell parameter doesn't begin from path delimiter)
 462  * @parameter argv    Array of strings (NULL-terminated) with parameters for command
 463  * @return 0 if successful, -1 otherwise
 464  */
 465
 466 int
 467 my_systemv_flags (int flags, const char *command, char *const argv[])
 468 {
 469     const char *execute_name;
 470     GPtrArray *args_array;
 471     int status = 0;
 472
 473     args_array = my_system_make_arg_array (flags, command);
 474
 475     execute_name = g_ptr_array_index (args_array, 0);
 476
 477     for (; argv != NULL && *argv != NULL; argv++)
 478         g_ptr_array_add (args_array, *argv);
 479
 480     g_ptr_array_add (args_array, NULL);
 481     status = my_systemv (execute_name, (char *const *) args_array->pdata);
 482
 483     g_ptr_array_free (args_array, TRUE);
 484
 485     return status;
 486 }
 487
 488 /* --------------------------------------------------------------------------------------------- */
 489 /**
 490  * Create pipe and run child process.
 491  *
 492  * @parameter command command line of child process
 493  * @parameter read_out do or don't read the stdout of child process
 494  * @parameter read_err do or don't read the stderr of child process
 495  * @parameter error contains pointer to object to handle error code and message
 496  *
 497  * @return newly created object of mc_pipe_t class in success, NULL otherwise
 498  */
 499
 500 mc_pipe_t *
 501 mc_popen (const char *command, gboolean read_out, gboolean read_err, GError ** error)
 502 {
 503     mc_pipe_t *p;
 504     const char *const argv[] = { "/bin/sh", "sh", "-c", command, NULL };
 505
 506     p = g_try_new (mc_pipe_t, 1);
 507     if (p == NULL)
 508     {
 509         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE, "%s",
 510                           _("Cannot create pipe descriptor"));
 511         goto ret_err;
 512     }
 513
 514     p->out.fd = -1;
 515     p->err.fd = -1;
 516
 517     if (!g_spawn_async_with_pipes
 518         (NULL, (gchar **) argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_FILE_AND_ARGV_ZERO, NULL,
 519          NULL, &p->child_pid, NULL, read_out ? &p->out.fd : NULL, read_err ? &p->err.fd : NULL,
 520          error))
 521     {
 522         mc_replace_error (error, MC_PIPE_ERROR_CREATE_PIPE_STREAM, "%s",
 523                           _("Cannot create pipe streams"));
 524         goto ret_err;
 525     }
 526
 527     p->out.buf[0] = '\0';
 528     p->out.len = MC_PIPE_BUFSIZE;
 529     p->out.null_term = FALSE;
 530
 531     p->err.buf[0] = '\0';
 532     p->err.len = MC_PIPE_BUFSIZE;
 533     p->err.null_term = FALSE;
 534
 535     return p;
 536
 537   ret_err:
 538     g_free (p);
 539     return NULL;
 540 }
 541
 542 /* --------------------------------------------------------------------------------------------- */
 543 /**
 544  * Read stdout and stderr of pipe asynchronously.
 545  *
 546  * @parameter p pipe descriptor
 547  *
 548  * The lengths of read data contain in p->out.len and p->err.len.
 549  *
 550  * Before read, p->xxx.len is an input. It defines the number of data to read.
 551  * Should not be greater than MC_PIPE_BUFSIZE.
 552  *
 553  * After read, p->xxx.len is an output and contains the following:
 554  *   p->xxx.len > 0: an actual length of read data stored in p->xxx.buf;
 555  *   p->xxx.len == MC_PIPE_STREAM_EOF: EOF of stream p->xxx;
 556  *   p->xxx.len == MC_PIPE_STREAM_UNREAD: stream p->xxx was not read;
 557  *   p->xxx.len == MC_PIPE_ERROR_READ: reading error, and p->xxx.errno is set appropriately.
 558  *
 559  * @parameter error contains pointer to object to handle error code and message
 560  */
 561
 562 void
 563 mc_pread (mc_pipe_t * p, GError ** error)
 564 {
 565     gboolean read_out, read_err;
 566     fd_set fds;
 567     int maxfd = 0;
 568     int res;
 569
 570     if (error != NULL)
 571         *error = NULL;
 572
 573     read_out = p->out.fd >= 0;
 574     read_err = p->err.fd >= 0;
 575
 576     if (!read_out && !read_err)
 577     {
 578         p->out.len = MC_PIPE_STREAM_UNREAD;
 579         p->err.len = MC_PIPE_STREAM_UNREAD;
 580         return;
 581     }
 582
 583     FD_ZERO (&fds);
 584     if (read_out)
 585     {
 586         FD_SET (p->out.fd, &fds);
 587         maxfd = p->out.fd;
 588     }
 589
 590     if (read_err)
 591     {
 592         FD_SET (p->err.fd, &fds);
 593         maxfd = MAX (maxfd, p->err.fd);
 594     }
 595
 596     /* no timeout */
 597     res = select (maxfd + 1, &fds, NULL, NULL, NULL);
 598     if (res < 0 && errno != EINTR)
 599     {
 600         mc_propagate_error (error, MC_PIPE_ERROR_READ,
 601                             _
 602                             ("Unexpected error in select() reading data from a child process:\n%s"),
 603                             unix_error_string (errno));
 604         return;
 605     }
 606
 607     if (read_out)
 608         mc_pread_stream (&p->out, &fds);
 609     else
 610         p->out.len = MC_PIPE_STREAM_UNREAD;
 611
 612     if (read_err)
 613         mc_pread_stream (&p->err, &fds);
 614     else
 615         p->err.len = MC_PIPE_STREAM_UNREAD;
 616 }
 617
 618 /* --------------------------------------------------------------------------------------------- */
 619 /**
 620  * Reads a line from @stream. Reading stops after an EOL or a newline. If a newline is read,
 621  * it is appended to the line.
 622  *
 623  * @stream mc_pipe_stream_t object
 624  *
 625  * @return newly created GString or NULL in case of EOL;
 626  */
 627
 628 GString *
 629 mc_pstream_get_string (mc_pipe_stream_t * ps)
 630 {
 631     char *s;
 632     size_t size, i;
 633     gboolean escape = FALSE;
 634
 635     g_return_val_if_fail (ps != NULL, NULL);
 636
 637     if (ps->len < 0)
 638         return NULL;
 639
 640     size = ps->len - ps->pos;
 641
 642     if (size == 0)
 643         return NULL;
 644
 645     s = ps->buf + ps->pos;
 646
 647     if (s[0] == '\0')
 648         return NULL;
 649
 650     /* find '\0' or unescaped '\n' */
 651     for (i = 0; i < size && !(s[i] == '\0' || (s[i] == '\n' && !escape)); i++)
 652         escape = s[i] == '\\' ? !escape : FALSE;
 653
 654     if (i != size && s[i] == '\n')
 655         i++;
 656
 657     ps->pos += i;
 658
 659     return g_string_new_len (s, i);
 660 }
 661
 662 /* --------------------------------------------------------------------------------------------- */
 663 /**
 664  * Close pipe and destroy pipe descriptor.
 665  *
 666  * @parameter p pipe descriptor
 667  * @parameter error contains pointer to object to handle error code and message
 668  */
 669
 670 void
 671 mc_pclose (mc_pipe_t * p, GError ** error)
 672 {
 673     int res;
 674
 675     if (p == NULL)
 676     {
 677         mc_replace_error (error, MC_PIPE_ERROR_READ, "%s",
 678                           _("Cannot close pipe descriptor (p == NULL)"));
 679         return;
 680     }
 681
 682     if (p->out.fd >= 0)
 683         res = close (p->out.fd);
 684     if (p->err.fd >= 0)
 685         res = close (p->err.fd);
 686
 687     do
 688     {
 689         int status;
 690
 691         res = waitpid (p->child_pid, &status, 0);
 692     }
 693     while (res < 0 && errno == EINTR);
 694
 695     if (res < 0)
 696         mc_replace_error (error, MC_PIPE_ERROR_READ, _("Unexpected error in waitpid():\n%s"),
 697                           unix_error_string (errno));
 698
 699     g_free (p);
 700 }
 701
 702 /* --------------------------------------------------------------------------------------------- */
 703
 704 /**
 705  * Perform tilde expansion if possible.
 706  *
 707  * @param directory pointer to the path
 708  *
 709  * @return newly allocated string, even if it's unchanged.
 710  */
 711
 712 char *
 713 tilde_expand (const char *directory)
 714 {
 715     struct passwd *passwd;
 716     const char *p, *q;
 717
 718     if (*directory != '~')
 719         return g_strdup (directory);
 720
 721     p = directory + 1;
 722
 723     /* d = "~" or d = "~/" */
 724     if (*p == '\0' || IS_PATH_SEP (*p))
 725     {
 726         passwd = getpwuid (geteuid ());
 727         q = IS_PATH_SEP (*p) ? p + 1 : "";
 728     }
 729     else
 730     {
 731         q = strchr (p, PATH_SEP);
 732         if (q == NULL)
 733             passwd = getpwnam (p);
 734         else
 735         {
 736             char *name;
 737
 738             name = g_strndup (p, q - p);
 739             passwd = getpwnam (name);
 740             q++;
 741             g_free (name);
 742         }
 743     }
 744
 745     /* If we can't figure the user name, leave tilde unexpanded */
 746     if (passwd == NULL)
 747         return g_strdup (directory);
 748
 749     return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
 750 }
 751
 752 /* --------------------------------------------------------------------------------------------- */
 753 /**
 754  * Canonicalize path.
 755  *
 756  * @param path path to file
 757  * @param flags canonicalization flags
 758  *
 759  * All modifications of @path are made in place.
 760  * Well formed UNC paths are modified only in the local part.
 761  */
 762
 763 void
 764 canonicalize_pathname_custom (char *path, canon_path_flags_t flags)
 765 {
 766     char *p, *s;
 767     char *lpath = path;         /* path without leading UNC part */
 768     const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
 769
 770     /* Detect and preserve UNC paths: //server/... */
 771     if ((flags & CANON_PATH_GUARDUNC) != 0 && IS_PATH_SEP (path[0]) && IS_PATH_SEP (path[1]))
 772     {
 773         for (p = path + 2; p[0] != '\0' && !IS_PATH_SEP (p[0]); p++)
 774             ;
 775         if (IS_PATH_SEP (p[0]) && p > path + 2)
 776             lpath = p;
 777     }
 778
 779     if (lpath[0] == '\0' || lpath[1] == '\0')
 780         return;
 781
 782     if ((flags & CANON_PATH_JOINSLASHES) != 0)
 783     {
 784         /* Collapse multiple slashes */
 785         for (p = lpath; *p != '\0'; p++)
 786             if (IS_PATH_SEP (p[0]) && IS_PATH_SEP (p[1]) && (p == lpath || *(p - 1) != ':'))
 787             {
 788                 s = p + 1;
 789                 while (IS_PATH_SEP (*(++s)))
 790                     ;
 791                 str_move (p + 1, s);
 792             }
 793
 794         /* Collapse "/./" -> "/" */
 795         for (p = lpath; *p != '\0';)
 796             if (IS_PATH_SEP (p[0]) && p[1] == '.' && IS_PATH_SEP (p[2]))
 797                 str_move (p, p + 2);
 798             else
 799                 p++;
 800     }
 801
 802     if ((flags & CANON_PATH_REMSLASHDOTS) != 0)
 803     {
 804         size_t len;
 805
 806         /* Remove trailing slashes */
 807         for (p = lpath + strlen (lpath) - 1; p > lpath && IS_PATH_SEP (*p); p--)
 808         {
 809             if (p >= lpath + url_delim_len - 1
 810                 && strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 811                 break;
 812             *p = '\0';
 813         }
 814
 815         /* Remove leading "./" */
 816         if (lpath[0] == '.' && IS_PATH_SEP (lpath[1]))
 817         {
 818             if (lpath[2] == '\0')
 819             {
 820                 lpath[1] = '\0';
 821                 return;
 822             }
 823
 824             str_move (lpath, lpath + 2);
 825         }
 826
 827         /* Remove trailing "/" or "/." */
 828         len = strlen (lpath);
 829         if (len < 2)
 830             return;
 831
 832         if (IS_PATH_SEP (lpath[len - 1])
 833             && (len < url_delim_len
 834                 || strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
 835                             url_delim_len) != 0))
 836             lpath[len - 1] = '\0';
 837         else if (lpath[len - 1] == '.' && IS_PATH_SEP (lpath[len - 2]))
 838         {
 839             if (len == 2)
 840             {
 841                 lpath[1] = '\0';
 842                 return;
 843             }
 844
 845             lpath[len - 2] = '\0';
 846         }
 847     }
 848
 849     /* Collapse "/.." with the previous part of path */
 850     if ((flags & CANON_PATH_REMDOUBLEDOTS) != 0)
 851     {
 852 #ifdef HAVE_CHARSET
 853         const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
 854 #endif /* HAVE_CHARSET */
 855
 856         for (p = lpath; p[0] != '\0' && p[1] != '\0' && p[2] != '\0';)
 857         {
 858             if (!IS_PATH_SEP (p[0]) || p[1] != '.' || p[2] != '.'
 859                 || (!IS_PATH_SEP (p[3]) && p[3] != '\0'))
 860             {
 861                 p++;
 862                 continue;
 863             }
 864
 865             /* search for the previous token */
 866             s = p - 1;
 867             if (s >= lpath + url_delim_len - 2
 868                 && strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 869             {
 870                 s -= (url_delim_len - 2);
 871                 while (s >= lpath && !IS_PATH_SEP (*s--))
 872                     ;
 873             }
 874
 875             while (s >= lpath)
 876             {
 877                 if (s - url_delim_len > lpath
 878                     && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 879                 {
 880                     char *vfs_prefix = s - url_delim_len;
 881                     vfs_class *vclass;
 882
 883                     while (vfs_prefix > lpath && !IS_PATH_SEP (*--vfs_prefix))
 884                         ;
 885                     if (IS_PATH_SEP (*vfs_prefix))
 886                         vfs_prefix++;
 887                     *(s - url_delim_len) = '\0';
 888
 889                     vclass = vfs_prefix_to_class (vfs_prefix);
 890                     *(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
 891
 892                     if (vclass != NULL && (vclass->flags & VFSF_REMOTE) != 0)
 893                     {
 894                         s = vfs_prefix;
 895                         continue;
 896                     }
 897                 }
 898
 899                 if (IS_PATH_SEP (*s))
 900                     break;
 901
 902                 s--;
 903             }
 904
 905             s++;
 906
 907             /* If the previous token is "..", we cannot collapse it */
 908             if (s[0] == '.' && s[1] == '.' && s + 2 == p)
 909             {
 910                 p += 3;
 911                 continue;
 912             }
 913
 914             if (p[3] != '\0')
 915             {
 916                 if (s == lpath && IS_PATH_SEP (*s))
 917                 {
 918                     /* "/../foo" -> "/foo" */
 919                     str_move (s + 1, p + 4);
 920                 }
 921                 else
 922                 {
 923                     /* "token/../foo" -> "foo" */
 924 #ifdef HAVE_CHARSET
 925                     if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 926                         && (is_supported_encoding (s + enc_prefix_len)))
 927                         /* special case: remove encoding */
 928                         str_move (s, p + 1);
 929                     else
 930 #endif /* HAVE_CHARSET */
 931                         str_move (s, p + 4);
 932                 }
 933
 934                 p = s > lpath ? s - 1 : s;
 935                 continue;
 936             }
 937
 938             /* trailing ".." */
 939             if (s == lpath)
 940             {
 941                 /* "token/.." -> "." */
 942                 if (!IS_PATH_SEP (lpath[0]))
 943                     lpath[0] = '.';
 944                 lpath[1] = '\0';
 945             }
 946             else
 947             {
 948                 /* "foo/token/.." -> "foo" */
 949                 if (s == lpath + 1)
 950                     s[0] = '\0';
 951 #ifdef HAVE_CHARSET
 952                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 953                          && (is_supported_encoding (s + enc_prefix_len)))
 954                 {
 955                     /* special case: remove encoding */
 956                     s[0] = '.';
 957                     s[1] = '.';
 958                     s[2] = '\0';
 959
 960                     /* search for the previous token */
 961                     /* IS_PATH_SEP (s[-1]) */
 962                     for (p = s - 1; p >= lpath && !IS_PATH_SEP (*p); p--)
 963                         ;
 964
 965                     if (p >= lpath)
 966                         continue;
 967                 }
 968 #endif /* HAVE_CHARSET */
 969                 else
 970                 {
 971                     if (s >= lpath + url_delim_len
 972                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 973                         *s = '\0';
 974                     else
 975                         s[-1] = '\0';
 976                 }
 977             }
 978
 979             break;
 980         }
 981     }
 982 }
 983
 984 /* --------------------------------------------------------------------------------------------- */
 985
 986 char *
 987 mc_realpath (const char *path, char *resolved_path)
 988 {
 989 #ifdef HAVE_CHARSET
 990     const char *p = path;
 991     gboolean absolute_path = FALSE;
 992
 993     if (IS_PATH_SEP (*p))
 994     {
 995         absolute_path = TRUE;
 996         p++;
 997     }
 998
 999     /* ignore encoding: skip "#enc:" */
1000     if (g_str_has_prefix (p, VFS_ENCODING_PREFIX))
1001     {
1002         p += strlen (VFS_ENCODING_PREFIX);
1003         p = strchr (p, PATH_SEP);
1004         if (p != NULL)
1005         {
1006             if (!absolute_path && p[1] != '\0')
1007                 p++;
1008
1009             path = p;
1010         }
1011     }
1012 #endif /* HAVE_CHARSET */
1013
1014 #ifdef HAVE_REALPATH
1015     return realpath (path, resolved_path);
1016 #else
1017     {
1018         char copy_path[PATH_MAX];
1019         char got_path[PATH_MAX];
1020         char *new_path = got_path;
1021         char *max_path;
1022 #ifdef S_IFLNK
1023         char link_path[PATH_MAX];
1024         int readlinks = 0;
1025         int n;
1026 #endif /* S_IFLNK */
1027
1028         /* Make a copy of the source path since we may need to modify it. */
1029         if (strlen (path) >= PATH_MAX - 2)
1030         {
1031             errno = ENAMETOOLONG;
1032             return NULL;
1033         }
1034
1035         strcpy (copy_path, path);
1036         path = copy_path;
1037         max_path = copy_path + PATH_MAX - 2;
1038         /* If it's a relative pathname use getwd for starters. */
1039         if (!IS_PATH_SEP (*path))
1040         {
1041             new_path = g_get_current_dir ();
1042             if (new_path == NULL)
1043                 strcpy (got_path, "");
1044             else
1045             {
1046                 g_snprintf (got_path, sizeof (got_path), "%s", new_path);
1047                 g_free (new_path);
1048                 new_path = got_path;
1049             }
1050
1051             new_path += strlen (got_path);
1052             if (!IS_PATH_SEP (new_path[-1]))
1053                 *new_path++ = PATH_SEP;
1054         }
1055         else
1056         {
1057             *new_path++ = PATH_SEP;
1058             path++;
1059         }
1060         /* Expand each slash-separated pathname component. */
1061         while (*path != '\0')
1062         {
1063             /* Ignore stray "/". */
1064             if (IS_PATH_SEP (*path))
1065             {
1066                 path++;
1067                 continue;
1068             }
1069             if (*path == '.')
1070             {
1071                 /* Ignore ".". */
1072                 if (path[1] == '\0' || IS_PATH_SEP (path[1]))
1073                 {
1074                     path++;
1075                     continue;
1076                 }
1077                 if (path[1] == '.')
1078                 {
1079                     if (path[2] == '\0' || IS_PATH_SEP (path[2]))
1080                     {
1081                         path += 2;
1082                         /* Ignore ".." at root. */
1083                         if (new_path == got_path + 1)
1084                             continue;
1085                         /* Handle ".." by backing up. */
1086                         while (!IS_PATH_SEP ((--new_path)[-1]))
1087                             ;
1088                         continue;
1089                     }
1090                 }
1091             }
1092             /* Safely copy the next pathname component. */
1093             while (*path != '\0' && !IS_PATH_SEP (*path))
1094             {
1095                 if (path > max_path)
1096                 {
1097                     errno = ENAMETOOLONG;
1098                     return NULL;
1099                 }
1100                 *new_path++ = *path++;
1101             }
1102 #ifdef S_IFLNK
1103             /* Protect against infinite loops. */
1104             if (readlinks++ > MAXSYMLINKS)
1105             {
1106                 errno = ELOOP;
1107                 return NULL;
1108             }
1109             /* See if latest pathname component is a symlink. */
1110             *new_path = '\0';
1111             n = readlink (got_path, link_path, PATH_MAX - 1);
1112             if (n < 0)
1113             {
1114                 /* EINVAL means the file exists but isn't a symlink. */
1115                 if (errno != EINVAL)
1116                 {
1117                     /* Make sure it's null terminated. */
1118                     *new_path = '\0';
1119                     strcpy (resolved_path, got_path);
1120                     return NULL;
1121                 }
1122             }
1123             else
1124             {
1125                 /* Note: readlink doesn't add the null byte. */
1126                 link_path[n] = '\0';
1127                 if (IS_PATH_SEP (*link_path))
1128                     /* Start over for an absolute symlink. */
1129                     new_path = got_path;
1130                 else
1131                     /* Otherwise back up over this component. */
1132                     while (!IS_PATH_SEP (*(--new_path)))
1133                         ;
1134                 /* Safe sex check. */
1135                 if (strlen (path) + n >= PATH_MAX - 2)
1136                 {
1137                     errno = ENAMETOOLONG;
1138                     return NULL;
1139                 }
1140                 /* Insert symlink contents into path. */
1141                 strcat (link_path, path);
1142                 strcpy (copy_path, link_path);
1143                 path = copy_path;
1144             }
1145 #endif /* S_IFLNK */
1146             *new_path++ = PATH_SEP;
1147         }
1148         /* Delete trailing slash but don't whomp a lone slash. */
1149         if (new_path != got_path + 1 && IS_PATH_SEP (new_path[-1]))
1150             new_path--;
1151         /* Make sure it's null terminated. */
1152         *new_path = '\0';
1153         strcpy (resolved_path, got_path);
1154         return resolved_path;
1155     }
1156 #endif /* HAVE_REALPATH */
1157 }
1158
1159 /* --------------------------------------------------------------------------------------------- */
1160 /**
1161  * Return the index of the permissions triplet
1162  *
1163  */
1164
1165 int
1166 get_user_permissions (struct stat *st)
1167 {
1168     static gboolean initialized = FALSE;
1169     static gid_t *groups;
1170     static int ngroups;
1171     static uid_t uid;
1172     int i;
1173
1174     if (!initialized)
1175     {
1176         uid = geteuid ();
1177
1178         ngroups = getgroups (0, NULL);
1179         if (ngroups == -1)
1180             ngroups = 0;        /* ignore errors */
1181
1182         /* allocate space for one element in addition to what
1183          * will be filled by getgroups(). */
1184         groups = g_new (gid_t, ngroups + 1);
1185
1186         if (ngroups != 0)
1187         {
1188             ngroups = getgroups (ngroups, groups);
1189             if (ngroups == -1)
1190                 ngroups = 0;    /* ignore errors */
1191         }
1192
1193         /* getgroups() may or may not return the effective group ID,
1194          * so we always include it at the end of the list. */
1195         groups[ngroups++] = getegid ();
1196
1197         initialized = TRUE;
1198     }
1199
1200     if (st->st_uid == uid || uid == 0)
1201         return 0;
1202
1203     for (i = 0; i < ngroups; i++)
1204         if (st->st_gid == groups[i])
1205             return 1;
1206
1207     return 2;
1208 }
1209
1210 /* --------------------------------------------------------------------------------------------- */
1211 /**
1212  * Build filename from arguments.
1213  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1214  */
1215
1216 char *
1217 mc_build_filenamev (const char *first_element, va_list args)
1218 {
1219     gboolean absolute;
1220     const char *element = first_element;
1221     GString *path;
1222     char *ret;
1223
1224     if (first_element == NULL)
1225         return NULL;
1226
1227     absolute = IS_PATH_SEP (*first_element);
1228
1229     path = g_string_new (absolute ? PATH_SEP_STR : "");
1230
1231     do
1232     {
1233         if (*element == '\0')
1234             element = va_arg (args, char *);
1235         else
1236         {
1237             char *tmp_element;
1238             const char *start;
1239
1240             tmp_element = g_strdup (element);
1241
1242             element = va_arg (args, char *);
1243
1244             canonicalize_pathname (tmp_element);
1245             start = IS_PATH_SEP (tmp_element[0]) ? tmp_element + 1 : tmp_element;
1246
1247             g_string_append (path, start);
1248             if (!IS_PATH_SEP (path->str[path->len - 1]) && element != NULL)
1249                 g_string_append_c (path, PATH_SEP);
1250
1251             g_free (tmp_element);
1252         }
1253     }
1254     while (element != NULL);
1255
1256     ret = g_string_free (path, FALSE);
1257     canonicalize_pathname (ret);
1258
1259     return ret;
1260 }
1261
1262 /* --------------------------------------------------------------------------------------------- */
1263 /**
1264  * Build filename from arguments.
1265  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1266  */
1267
1268 char *
1269 mc_build_filename (const char *first_element, ...)
1270 {
1271     va_list args;
1272     char *ret;
1273
1274     if (first_element == NULL)
1275         return NULL;
1276
1277     va_start (args, first_element);
1278     ret = mc_build_filenamev (first_element, args);
1279     va_end (args);
1280     return ret;
1281 }
1282
1283 /* --------------------------------------------------------------------------------------------- */