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                         && (is_supported_encoding (s + enc_prefix_len)))
 925                         /* special case: remove encoding */
 926                         str_move (s, p + 1);
 927                     else
 928 #endif /* HAVE_CHARSET */
 929                         str_move (s, p + 4);
 930                 }
 931
 932                 p = s > lpath ? s - 1 : s;
 933                 continue;
 934             }
 935
 936             /* trailing ".." */
 937             if (s == lpath)
 938             {
 939                 /* "token/.." -> "." */
 940                 if (!IS_PATH_SEP (lpath[0]))
 941                     lpath[0] = '.';
 942                 lpath[1] = '\0';
 943             }
 944             else
 945             {
 946                 /* "foo/token/.." -> "foo" */
 947                 if (s == lpath + 1)
 948                     s[0] = '\0';
 949 #ifdef HAVE_CHARSET
 950                 else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
 951                          && (is_supported_encoding (s + enc_prefix_len)))
 952                 {
 953                     /* special case: remove encoding */
 954                     s[0] = '.';
 955                     s[1] = '.';
 956                     s[2] = '\0';
 957
 958                     /* search for the previous token */
 959                     /* IS_PATH_SEP (s[-1]) */
 960                     for (p = s - 1; p >= lpath && !IS_PATH_SEP (*p); p--)
 961                         ;
 962
 963                     if (p >= lpath)
 964                         continue;
 965                 }
 966 #endif /* HAVE_CHARSET */
 967                 else
 968                 {
 969                     if (s >= lpath + url_delim_len
 970                         && strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
 971                         *s = '\0';
 972                     else
 973                         s[-1] = '\0';
 974                 }
 975             }
 976
 977             break;
 978         }
 979     }
 980 }
 981
 982 /* --------------------------------------------------------------------------------------------- */
 983
 984 char *
 985 mc_realpath (const char *path, char *resolved_path)
 986 {
 987 #ifdef HAVE_CHARSET
 988     const char *p = path;
 989     gboolean absolute_path = FALSE;
 990
 991     if (IS_PATH_SEP (*p))
 992     {
 993         absolute_path = TRUE;
 994         p++;
 995     }
 996
 997     /* ignore encoding: skip "#enc:" */
 998     if (g_str_has_prefix (p, VFS_ENCODING_PREFIX))
 999     {
1000         p += strlen (VFS_ENCODING_PREFIX);
1001         p = strchr (p, PATH_SEP);
1002         if (p != NULL)
1003         {
1004             if (!absolute_path && p[1] != '\0')
1005                 p++;
1006
1007             path = p;
1008         }
1009     }
1010 #endif /* HAVE_CHARSET */
1011
1012 #ifdef HAVE_REALPATH
1013     return realpath (path, resolved_path);
1014 #else
1015     {
1016         char copy_path[PATH_MAX];
1017         char got_path[PATH_MAX];
1018         char *new_path = got_path;
1019         char *max_path;
1020 #ifdef S_IFLNK
1021         char link_path[PATH_MAX];
1022         int readlinks = 0;
1023         int n;
1024 #endif /* S_IFLNK */
1025
1026         /* Make a copy of the source path since we may need to modify it. */
1027         if (strlen (path) >= PATH_MAX - 2)
1028         {
1029             errno = ENAMETOOLONG;
1030             return NULL;
1031         }
1032
1033         strcpy (copy_path, path);
1034         path = copy_path;
1035         max_path = copy_path + PATH_MAX - 2;
1036         /* If it's a relative pathname use getwd for starters. */
1037         if (!IS_PATH_SEP (*path))
1038         {
1039             new_path = g_get_current_dir ();
1040             if (new_path == NULL)
1041                 strcpy (got_path, "");
1042             else
1043             {
1044                 g_snprintf (got_path, sizeof (got_path), "%s", new_path);
1045                 g_free (new_path);
1046                 new_path = got_path;
1047             }
1048
1049             new_path += strlen (got_path);
1050             if (!IS_PATH_SEP (new_path[-1]))
1051                 *new_path++ = PATH_SEP;
1052         }
1053         else
1054         {
1055             *new_path++ = PATH_SEP;
1056             path++;
1057         }
1058         /* Expand each slash-separated pathname component. */
1059         while (*path != '\0')
1060         {
1061             /* Ignore stray "/". */
1062             if (IS_PATH_SEP (*path))
1063             {
1064                 path++;
1065                 continue;
1066             }
1067             if (*path == '.')
1068             {
1069                 /* Ignore ".". */
1070                 if (path[1] == '\0' || IS_PATH_SEP (path[1]))
1071                 {
1072                     path++;
1073                     continue;
1074                 }
1075                 if (path[1] == '.')
1076                 {
1077                     if (path[2] == '\0' || IS_PATH_SEP (path[2]))
1078                     {
1079                         path += 2;
1080                         /* Ignore ".." at root. */
1081                         if (new_path == got_path + 1)
1082                             continue;
1083                         /* Handle ".." by backing up. */
1084                         while (!IS_PATH_SEP ((--new_path)[-1]))
1085                             ;
1086                         continue;
1087                     }
1088                 }
1089             }
1090             /* Safely copy the next pathname component. */
1091             while (*path != '\0' && !IS_PATH_SEP (*path))
1092             {
1093                 if (path > max_path)
1094                 {
1095                     errno = ENAMETOOLONG;
1096                     return NULL;
1097                 }
1098                 *new_path++ = *path++;
1099             }
1100 #ifdef S_IFLNK
1101             /* Protect against infinite loops. */
1102             if (readlinks++ > MAXSYMLINKS)
1103             {
1104                 errno = ELOOP;
1105                 return NULL;
1106             }
1107             /* See if latest pathname component is a symlink. */
1108             *new_path = '\0';
1109             n = readlink (got_path, link_path, PATH_MAX - 1);
1110             if (n < 0)
1111             {
1112                 /* EINVAL means the file exists but isn't a symlink. */
1113                 if (errno != EINVAL)
1114                 {
1115                     /* Make sure it's null terminated. */
1116                     *new_path = '\0';
1117                     strcpy (resolved_path, got_path);
1118                     return NULL;
1119                 }
1120             }
1121             else
1122             {
1123                 /* Note: readlink doesn't add the null byte. */
1124                 link_path[n] = '\0';
1125                 if (IS_PATH_SEP (*link_path))
1126                     /* Start over for an absolute symlink. */
1127                     new_path = got_path;
1128                 else
1129                     /* Otherwise back up over this component. */
1130                     while (!IS_PATH_SEP (*(--new_path)))
1131                         ;
1132                 /* Safe sex check. */
1133                 if (strlen (path) + n >= PATH_MAX - 2)
1134                 {
1135                     errno = ENAMETOOLONG;
1136                     return NULL;
1137                 }
1138                 /* Insert symlink contents into path. */
1139                 strcat (link_path, path);
1140                 strcpy (copy_path, link_path);
1141                 path = copy_path;
1142             }
1143 #endif /* S_IFLNK */
1144             *new_path++ = PATH_SEP;
1145         }
1146         /* Delete trailing slash but don't whomp a lone slash. */
1147         if (new_path != got_path + 1 && IS_PATH_SEP (new_path[-1]))
1148             new_path--;
1149         /* Make sure it's null terminated. */
1150         *new_path = '\0';
1151         strcpy (resolved_path, got_path);
1152         return resolved_path;
1153     }
1154 #endif /* HAVE_REALPATH */
1155 }
1156
1157 /* --------------------------------------------------------------------------------------------- */
1158 /**
1159  * Return the index of the permissions triplet
1160  *
1161  */
1162
1163 int
1164 get_user_permissions (struct stat *st)
1165 {
1166     static gboolean initialized = FALSE;
1167     static gid_t *groups;
1168     static int ngroups;
1169     static uid_t uid;
1170     int i;
1171
1172     if (!initialized)
1173     {
1174         uid = geteuid ();
1175
1176         ngroups = getgroups (0, NULL);
1177         if (ngroups == -1)
1178             ngroups = 0;        /* ignore errors */
1179
1180         /* allocate space for one element in addition to what
1181          * will be filled by getgroups(). */
1182         groups = g_new (gid_t, ngroups + 1);
1183
1184         if (ngroups != 0)
1185         {
1186             ngroups = getgroups (ngroups, groups);
1187             if (ngroups == -1)
1188                 ngroups = 0;    /* ignore errors */
1189         }
1190
1191         /* getgroups() may or may not return the effective group ID,
1192          * so we always include it at the end of the list. */
1193         groups[ngroups++] = getegid ();
1194
1195         initialized = TRUE;
1196     }
1197
1198     if (st->st_uid == uid || uid == 0)
1199         return 0;
1200
1201     for (i = 0; i < ngroups; i++)
1202         if (st->st_gid == groups[i])
1203             return 1;
1204
1205     return 2;
1206 }
1207
1208 /* --------------------------------------------------------------------------------------------- */
1209 /**
1210  * Build filename from arguments.
1211  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1212  */
1213
1214 char *
1215 mc_build_filenamev (const char *first_element, va_list args)
1216 {
1217     gboolean absolute;
1218     const char *element = first_element;
1219     GString *path;
1220     char *ret;
1221
1222     if (first_element == NULL)
1223         return NULL;
1224
1225     absolute = IS_PATH_SEP (*first_element);
1226
1227     path = g_string_new (absolute ? PATH_SEP_STR : "");
1228
1229     do
1230     {
1231         if (*element == '\0')
1232             element = va_arg (args, char *);
1233         else
1234         {
1235             char *tmp_element;
1236             const char *start;
1237
1238             tmp_element = g_strdup (element);
1239
1240             element = va_arg (args, char *);
1241
1242             canonicalize_pathname (tmp_element);
1243             start = IS_PATH_SEP (tmp_element[0]) ? tmp_element + 1 : tmp_element;
1244
1245             g_string_append (path, start);
1246             if (!IS_PATH_SEP (path->str[path->len - 1]) && element != NULL)
1247                 g_string_append_c (path, PATH_SEP);
1248
1249             g_free (tmp_element);
1250         }
1251     }
1252     while (element != NULL);
1253
1254     ret = g_string_free (path, FALSE);
1255     canonicalize_pathname (ret);
1256
1257     return ret;
1258 }
1259
1260 /* --------------------------------------------------------------------------------------------- */
1261 /**
1262  * Build filename from arguments.
1263  * Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
1264  */
1265
1266 char *
1267 mc_build_filename (const char *first_element, ...)
1268 {
1269     va_list args;
1270     char *ret;
1271
1272     if (first_element == NULL)
1273         return NULL;
1274
1275     va_start (args, first_element);
1276     ret = mc_build_filenamev (first_element, args);
1277     va_end (args);
1278     return ret;
1279 }
1280
1281 /* --------------------------------------------------------------------------------------------- */