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