2011-10-15 14:56:47 +04:00
|
|
|
/*
|
|
|
|
Various utilities - Unix variants
|
|
|
|
|
2014-01-05 12:37:43 +04:00
|
|
|
Copyright (C) 1994-2014
|
2014-02-12 10:33:10 +04:00
|
|
|
Free Software Foundation, Inc.
|
2011-10-15 14:56:47 +04:00
|
|
|
|
|
|
|
Written by:
|
|
|
|
Miguel de Icaza, 1994, 1995, 1996
|
|
|
|
Janne Kukonlehto, 1994, 1995, 1996
|
|
|
|
Dugan Porter, 1994, 1995, 1996
|
|
|
|
Jakub Jelinek, 1994, 1995, 1996
|
|
|
|
Mauricio Plaza, 1994, 1995, 1996
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2005-01-13 22:37:46 +03:00
|
|
|
The mc_realpath routine is mostly from uClibc package, written
|
|
|
|
by Rick Sladkey <jrs@world.std.com>
|
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
This file is part of the Midnight Commander.
|
2010-04-30 17:31:06 +04:00
|
|
|
|
2011-10-15 14:56:47 +04:00
|
|
|
The Midnight Commander is free software: you can redistribute it
|
|
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
|
|
published by the Free Software Foundation, either version 3 of the License,
|
|
|
|
or (at your option) any later version.
|
|
|
|
|
|
|
|
The Midnight Commander is distributed in the hope that it will be useful,
|
1998-02-27 07:54:42 +03:00
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2011-10-15 14:56:47 +04:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2009-02-05 21:28:18 +03:00
|
|
|
/** \file utilunix.c
|
|
|
|
* \brief Source: various utilities - Unix variant
|
|
|
|
*/
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <config.h>
|
2005-02-08 12:04:03 +03:00
|
|
|
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <signal.h>
|
|
|
|
#include <stdarg.h>
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <stdio.h>
|
2005-02-08 12:04:03 +03:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2009-02-06 02:30:45 +03:00
|
|
|
#include <fcntl.h>
|
2012-01-04 15:44:01 +04:00
|
|
|
#ifdef HAVE_SYS_PARAM_H
|
2005-02-08 12:04:03 +03:00
|
|
|
#include <sys/param.h>
|
2012-01-04 15:44:01 +04:00
|
|
|
#endif
|
1998-02-27 07:54:42 +03:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
2009-02-27 14:54:26 +03:00
|
|
|
#include <sys/wait.h>
|
2001-09-11 06:18:02 +04:00
|
|
|
#ifdef HAVE_SYS_IOCTL_H
|
2010-11-08 13:21:45 +03:00
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_GET_PROCESS_STATS
|
|
|
|
#include <sys/procstats.h>
|
1998-02-27 07:54:42 +03:00
|
|
|
#endif
|
2009-02-06 02:30:45 +03:00
|
|
|
#include <pwd.h>
|
|
|
|
#include <grp.h>
|
2001-09-03 09:07:40 +04:00
|
|
|
|
2010-01-20 18:11:52 +03:00
|
|
|
#include "lib/global.h"
|
2013-12-20 11:26:56 +04:00
|
|
|
|
|
|
|
#include "lib/unixcompat.h"
|
2011-02-15 16:44:17 +03:00
|
|
|
#include "lib/vfs/vfs.h" /* VFS_ENCODING_PREFIX */
|
2010-11-11 16:58:29 +03:00
|
|
|
#include "lib/strutil.h" /* str_move() */
|
|
|
|
#include "lib/util.h"
|
2010-11-12 11:03:57 +03:00
|
|
|
#include "lib/widget.h" /* message() */
|
2011-06-14 16:09:59 +04:00
|
|
|
#include "lib/vfs/xdirentry.h"
|
2010-09-10 11:27:21 +04:00
|
|
|
|
2010-09-13 13:32:27 +04:00
|
|
|
#ifdef HAVE_CHARSET
|
2011-02-18 16:11:57 +03:00
|
|
|
#include "lib/charsets.h"
|
2010-09-13 13:32:27 +04:00
|
|
|
#endif
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2011-02-18 16:11:57 +03:00
|
|
|
#include "utilunix.h"
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/*** global variables ****************************************************************************/
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
struct sigaction startup_handler;
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/*** file scope macro definitions ****************************************************************/
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
#define UID_CACHE_SIZE 200
|
|
|
|
#define GID_CACHE_SIZE 30
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* Pipes are guaranteed to be able to hold at least 4096 bytes */
|
|
|
|
/* More than that would be unportable */
|
|
|
|
#define MAX_PIPE_SIZE 4096
|
|
|
|
|
|
|
|
/*** file scope type declarations ****************************************************************/
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
int index;
|
1998-02-27 07:54:42 +03:00
|
|
|
char *string;
|
|
|
|
} int_cache;
|
|
|
|
|
2013-01-06 01:30:56 +04:00
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
FORK_ERROR = -1,
|
|
|
|
FORK_CHILD,
|
|
|
|
FORK_PARENT,
|
|
|
|
} my_fork_state_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
struct sigaction intr;
|
|
|
|
struct sigaction quit;
|
|
|
|
struct sigaction stop;
|
|
|
|
} my_system_sigactions_t;
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/*** file scope variables ************************************************************************/
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
static int_cache uid_cache[UID_CACHE_SIZE];
|
|
|
|
static int_cache gid_cache[GID_CACHE_SIZE];
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
static int error_pipe[2]; /* File descriptors of error pipe */
|
|
|
|
static int old_error; /* File descriptor of old standard error */
|
|
|
|
|
|
|
|
/*** file scope functions ************************************************************************/
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
static char *
|
|
|
|
i_cache_match (int id, int_cache * cache, int size)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++)
|
2010-04-30 17:31:06 +04:00
|
|
|
if (cache[i].index == id)
|
|
|
|
return cache[i].string;
|
1998-02-27 07:54:42 +03:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
static void
|
|
|
|
i_cache_add (int id, int_cache * cache, int size, char *text, int *last)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2010-04-30 17:31:06 +04:00
|
|
|
g_free (cache[*last].string);
|
|
|
|
cache[*last].string = g_strdup (text);
|
|
|
|
cache[*last].index = id;
|
|
|
|
*last = ((*last) + 1) % size;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2013-01-06 01:30:56 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static my_fork_state_t
|
|
|
|
my_fork (void)
|
|
|
|
{
|
|
|
|
pid_t pid;
|
|
|
|
|
|
|
|
pid = fork ();
|
|
|
|
|
|
|
|
if (pid < 0)
|
|
|
|
{
|
|
|
|
fprintf (stderr, "\n\nfork () = -1\n");
|
|
|
|
return FORK_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pid == 0)
|
|
|
|
return FORK_CHILD;
|
|
|
|
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
if (waitpid (pid, &status, 0) > 0)
|
|
|
|
return WEXITSTATUS (status) == 0 ? FORK_PARENT : FORK_ERROR;
|
|
|
|
|
|
|
|
if (errno != EINTR)
|
|
|
|
return FORK_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void
|
|
|
|
my_system__save_sigaction_handlers (my_system_sigactions_t * sigactions)
|
|
|
|
{
|
|
|
|
struct sigaction ignore;
|
|
|
|
|
2013-11-17 09:55:18 +04:00
|
|
|
memset (&ignore, 0, sizeof (ignore));
|
2013-01-06 01:30:56 +04:00
|
|
|
ignore.sa_handler = SIG_IGN;
|
|
|
|
sigemptyset (&ignore.sa_mask);
|
|
|
|
|
|
|
|
sigaction (SIGINT, &ignore, &sigactions->intr);
|
|
|
|
sigaction (SIGQUIT, &ignore, &sigactions->quit);
|
|
|
|
|
|
|
|
/* Restore the original SIGTSTP handler, we don't want ncurses' */
|
|
|
|
/* handler messing the screen after the SIGCONT */
|
|
|
|
sigaction (SIGTSTP, &startup_handler, &sigactions->stop);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void
|
|
|
|
my_system__restore_sigaction_handlers (my_system_sigactions_t * sigactions)
|
|
|
|
{
|
|
|
|
sigaction (SIGINT, &sigactions->intr, NULL);
|
|
|
|
sigaction (SIGQUIT, &sigactions->quit, NULL);
|
|
|
|
sigaction (SIGTSTP, &sigactions->stop, NULL);
|
|
|
|
}
|
|
|
|
|
2013-01-10 17:22:59 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static GPtrArray *
|
|
|
|
my_system_make_arg_array (int flags, const char *shell, char **execute_name)
|
|
|
|
{
|
|
|
|
GPtrArray *args_array;
|
|
|
|
|
|
|
|
args_array = g_ptr_array_new ();
|
|
|
|
|
|
|
|
if ((flags & EXECUTE_AS_SHELL) != 0)
|
|
|
|
{
|
|
|
|
g_ptr_array_add (args_array, g_strdup (shell));
|
|
|
|
g_ptr_array_add (args_array, g_strdup ("-c"));
|
|
|
|
*execute_name = g_strdup (shell);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *shell_token;
|
|
|
|
|
|
|
|
shell_token = shell != NULL ? strchr (shell, ' ') : NULL;
|
|
|
|
if (shell_token == NULL)
|
|
|
|
*execute_name = g_strdup (shell);
|
|
|
|
else
|
|
|
|
*execute_name = g_strndup (shell, (gsize) (shell_token - shell));
|
|
|
|
|
|
|
|
g_ptr_array_add (args_array, g_strdup (shell));
|
|
|
|
}
|
|
|
|
return args_array;
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/*** public functions ****************************************************************************/
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
char *
|
|
|
|
get_owner (int uid)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
struct passwd *pwd;
|
2010-04-30 17:31:06 +04:00
|
|
|
char *name;
|
1998-04-17 04:21:53 +04:00
|
|
|
static int uid_last;
|
2010-04-30 17:31:06 +04:00
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
name = i_cache_match (uid, uid_cache, UID_CACHE_SIZE);
|
|
|
|
if (name != NULL)
|
2010-04-30 17:31:06 +04:00
|
|
|
return name;
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
pwd = getpwuid (uid);
|
2010-03-30 22:59:41 +04:00
|
|
|
if (pwd != NULL)
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
|
|
|
i_cache_add (uid, uid_cache, UID_CACHE_SIZE, pwd->pw_name, &uid_last);
|
|
|
|
return pwd->pw_name;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2010-04-30 17:31:06 +04:00
|
|
|
else
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
static char ibuf[10];
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
g_snprintf (ibuf, sizeof (ibuf), "%d", uid);
|
|
|
|
return ibuf;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
char *
|
|
|
|
get_group (int gid)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
struct group *grp;
|
|
|
|
char *name;
|
2010-04-30 17:31:06 +04:00
|
|
|
static int gid_last;
|
|
|
|
|
2010-03-30 22:59:41 +04:00
|
|
|
name = i_cache_match (gid, gid_cache, GID_CACHE_SIZE);
|
|
|
|
if (name != NULL)
|
2010-04-30 17:31:06 +04:00
|
|
|
return name;
|
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
grp = getgrgid (gid);
|
2010-03-30 22:59:41 +04:00
|
|
|
if (grp != NULL)
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
|
|
|
i_cache_add (gid, gid_cache, GID_CACHE_SIZE, grp->gr_name, &gid_last);
|
|
|
|
return grp->gr_name;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
static char gbuf[10];
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
g_snprintf (gbuf, sizeof (gbuf), "%d", gid);
|
|
|
|
return gbuf;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
1998-02-27 07:54:42 +03:00
|
|
|
/* Since ncurses uses a handler that automatically refreshes the */
|
|
|
|
/* screen after a SIGCONT, and we don't want this behavior when */
|
|
|
|
/* spawning a child, we save the original handler here */
|
2010-11-08 13:21:45 +03:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
void
|
|
|
|
save_stop_handler (void)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
sigaction (SIGTSTP, NULL, &startup_handler);
|
|
|
|
}
|
|
|
|
|
2013-01-05 14:48:50 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Wrapper for _exit() system call.
|
|
|
|
* The _exit() function has gcc's attribute 'noreturn', and this is reason why we can't
|
|
|
|
* mock the call.
|
|
|
|
*
|
|
|
|
* @param status exit code
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
my_exit (int status)
|
|
|
|
{
|
|
|
|
_exit (status);
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2013-01-09 21:25:04 +04:00
|
|
|
/**
|
|
|
|
* Call external programs.
|
|
|
|
*
|
|
|
|
* @parameter flags addition conditions for running external programs.
|
|
|
|
* @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
|
|
|
|
* Shell (or command) will be found in paths described in PATH variable
|
|
|
|
* (if shell parameter doesn't begin from path delimiter)
|
|
|
|
* @parameter command Command for shell (or first parameter for command, if flags contain EXECUTE_AS_SHELL)
|
|
|
|
* @return 0 if successfull, -1 otherwise
|
|
|
|
*/
|
2010-11-08 13:21:45 +03:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
int
|
|
|
|
my_system (int flags, const char *shell, const char *command)
|
2013-01-09 21:25:04 +04:00
|
|
|
{
|
|
|
|
return my_systeml (flags, shell, command, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Call external programs with various parameters number.
|
|
|
|
*
|
|
|
|
* @parameter flags addition conditions for running external programs.
|
|
|
|
* @parameter shell shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
|
|
|
|
* Shell (or command) will be found in pathes described in PATH variable
|
|
|
|
* (if shell parameter doesn't begin from path delimiter)
|
|
|
|
* @parameter ... Command for shell with addition parameters for shell
|
|
|
|
* (or parameters for command, if flags contain EXECUTE_AS_SHELL).
|
|
|
|
* Should be NULL terminated.
|
|
|
|
* @return 0 if successfull, -1 otherwise
|
|
|
|
*/
|
|
|
|
|
2013-01-10 17:22:59 +04:00
|
|
|
|
2013-01-09 21:25:04 +04:00
|
|
|
int
|
|
|
|
my_systeml (int flags, const char *shell, ...)
|
|
|
|
{
|
|
|
|
GPtrArray *args_array;
|
|
|
|
int status = 0;
|
|
|
|
va_list vargs;
|
|
|
|
char *one_arg;
|
|
|
|
|
|
|
|
args_array = g_ptr_array_new ();
|
|
|
|
|
|
|
|
va_start (vargs, shell);
|
|
|
|
while ((one_arg = va_arg (vargs, char *)) != NULL)
|
2013-01-10 17:22:59 +04:00
|
|
|
g_ptr_array_add (args_array, one_arg);
|
2013-01-09 21:25:04 +04:00
|
|
|
va_end (vargs);
|
|
|
|
|
|
|
|
g_ptr_array_add (args_array, NULL);
|
2013-01-10 17:22:59 +04:00
|
|
|
status = my_systemv_flags (flags, shell, (char *const *) args_array->pdata);
|
2013-01-09 21:25:04 +04:00
|
|
|
|
|
|
|
g_ptr_array_free (args_array, TRUE);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Call external programs with array of strings as parameters.
|
|
|
|
*
|
|
|
|
* @parameter command command to run. Command will be found in paths described in PATH variable
|
|
|
|
* (if command parameter doesn't begin from path delimiter)
|
|
|
|
* @parameter argv Array of strings (NULL-terminated) with parameters for command
|
|
|
|
* @return 0 if successfull, -1 otherwise
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
my_systemv (const char *command, char *const argv[])
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2013-01-06 01:30:56 +04:00
|
|
|
my_fork_state_t fork_state;
|
1998-02-27 07:54:42 +03:00
|
|
|
int status = 0;
|
2013-01-06 01:30:56 +04:00
|
|
|
my_system_sigactions_t sigactions;
|
2010-04-30 17:31:06 +04:00
|
|
|
|
2013-01-06 01:30:56 +04:00
|
|
|
my_system__save_sigaction_handlers (&sigactions);
|
2010-04-30 17:31:06 +04:00
|
|
|
|
2013-01-06 01:30:56 +04:00
|
|
|
fork_state = my_fork ();
|
|
|
|
switch (fork_state)
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
2013-01-06 01:30:56 +04:00
|
|
|
case FORK_ERROR:
|
2010-04-17 23:16:36 +04:00
|
|
|
status = -1;
|
2013-01-06 01:30:56 +04:00
|
|
|
break;
|
|
|
|
case FORK_CHILD:
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
2013-01-06 01:30:56 +04:00
|
|
|
signal (SIGINT, SIG_DFL);
|
|
|
|
signal (SIGQUIT, SIG_DFL);
|
|
|
|
signal (SIGTSTP, SIG_DFL);
|
|
|
|
signal (SIGCHLD, SIG_DFL);
|
2010-04-30 17:31:06 +04:00
|
|
|
|
2013-01-09 21:25:04 +04:00
|
|
|
execvp (command, argv);
|
2013-01-06 01:30:56 +04:00
|
|
|
my_exit (127); /* Exec error */
|
2010-04-17 23:16:36 +04:00
|
|
|
}
|
2013-01-06 01:30:56 +04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
status = 0;
|
|
|
|
break;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2013-01-06 01:30:56 +04:00
|
|
|
my_system__restore_sigaction_handlers (&sigactions);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-04-17 23:16:36 +04:00
|
|
|
return status;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2013-01-10 17:22:59 +04:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Call external programs with flags and with array of strings as parameters.
|
|
|
|
*
|
|
|
|
* @parameter flags addition conditions for running external programs.
|
|
|
|
* @parameter command shell (if flags contain EXECUTE_AS_SHELL), command to run otherwise.
|
|
|
|
* Shell (or command) will be found in paths described in PATH variable
|
|
|
|
* (if shell parameter doesn't begin from path delimiter)
|
|
|
|
* @parameter argv Array of strings (NULL-terminated) with parameters for command
|
|
|
|
* @return 0 if successfull, -1 otherwise
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
|
|
my_systemv_flags (int flags, const char *command, char *const argv[])
|
|
|
|
{
|
|
|
|
char *execute_name = NULL;
|
|
|
|
GPtrArray *args_array;
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
args_array = my_system_make_arg_array (flags, command, &execute_name);
|
|
|
|
|
|
|
|
for (; argv != NULL && *argv != NULL; argv++)
|
|
|
|
g_ptr_array_add (args_array, *argv);
|
|
|
|
|
|
|
|
g_ptr_array_add (args_array, NULL);
|
|
|
|
status = my_systemv (execute_name, (char *const *) args_array->pdata);
|
|
|
|
|
|
|
|
g_free (execute_name);
|
|
|
|
g_ptr_array_free (args_array, TRUE);
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2012-08-31 18:05:29 +04:00
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/**
|
2003-11-27 12:45:22 +03:00
|
|
|
* Perform tilde expansion if possible.
|
2012-08-31 18:05:29 +04:00
|
|
|
*
|
|
|
|
* @param directory pointer to the path
|
|
|
|
*
|
2012-11-05 17:57:50 +04:00
|
|
|
* @return newly allocated string, even if it's unchanged.
|
2003-11-27 12:45:22 +03:00
|
|
|
*/
|
2010-11-08 13:21:45 +03:00
|
|
|
|
2003-11-27 12:45:22 +03:00
|
|
|
char *
|
|
|
|
tilde_expand (const char *directory)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
|
|
|
struct passwd *passwd;
|
2003-11-28 18:23:19 +03:00
|
|
|
const char *p, *q;
|
2003-11-27 12:45:22 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
if (*directory != '~')
|
2010-04-30 17:31:06 +04:00
|
|
|
return g_strdup (directory);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2003-11-28 18:23:19 +03:00
|
|
|
p = directory + 1;
|
2003-11-27 12:45:22 +03:00
|
|
|
|
1998-02-27 07:54:42 +03:00
|
|
|
/* d = "~" or d = "~/" */
|
2010-04-30 17:31:06 +04:00
|
|
|
if (!(*p) || (*p == PATH_SEP))
|
|
|
|
{
|
|
|
|
passwd = getpwuid (geteuid ());
|
|
|
|
q = (*p == PATH_SEP) ? p + 1 : "";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
q = strchr (p, PATH_SEP);
|
|
|
|
if (!q)
|
|
|
|
{
|
|
|
|
passwd = getpwnam (p);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
char *name;
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
name = g_strndup (p, q - p);
|
|
|
|
passwd = getpwnam (name);
|
|
|
|
q++;
|
|
|
|
g_free (name);
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2003-11-27 12:45:22 +03:00
|
|
|
/* If we can't figure the user name, leave tilde unexpanded */
|
1998-02-27 07:54:42 +03:00
|
|
|
if (!passwd)
|
2010-04-30 17:31:06 +04:00
|
|
|
return g_strdup (directory);
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2004-09-24 19:05:28 +04:00
|
|
|
return g_strconcat (passwd->pw_dir, PATH_SEP_STR, q, (char *) NULL);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Creates a pipe to hold standard error for a later analysis.
|
|
|
|
* The pipe can hold 4096 bytes. Make sure no more is written
|
|
|
|
* or a deadlock might occur.
|
|
|
|
*/
|
2002-09-11 08:58:24 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
void
|
|
|
|
open_error_pipe (void)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2010-04-30 17:31:06 +04:00
|
|
|
if (pipe (error_pipe) < 0)
|
|
|
|
{
|
2010-05-15 18:45:13 +04:00
|
|
|
message (D_NORMAL, _("Warning"), _("Pipe failed"));
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2013-12-20 11:26:56 +04:00
|
|
|
old_error = dup (STDERR_FILENO);
|
|
|
|
if (old_error < 0 || close (STDERR_FILENO) != 0 || dup (error_pipe[1]) != STDERR_FILENO)
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
2010-05-15 18:45:13 +04:00
|
|
|
message (D_NORMAL, _("Warning"), _("Dup failed"));
|
2009-06-20 17:29:44 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
close (error_pipe[0]);
|
|
|
|
error_pipe[0] = -1;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
2009-06-26 14:24:10 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Settng stderr in nonblocking mode as we close it earlier, than
|
|
|
|
* program stops. We try to read some error at program startup,
|
|
|
|
* but we should not block on it.
|
|
|
|
*
|
|
|
|
* TODO: make piped stdin/stderr poll()/select()able to get rid
|
|
|
|
* of following hack.
|
|
|
|
*/
|
|
|
|
int fd_flags;
|
|
|
|
fd_flags = fcntl (error_pipe[0], F_GETFL, NULL);
|
|
|
|
if (fd_flags != -1)
|
|
|
|
{
|
|
|
|
fd_flags |= O_NONBLOCK;
|
2010-04-30 17:31:06 +04:00
|
|
|
if (fcntl (error_pipe[0], F_SETFL, fd_flags) == -1)
|
2009-06-26 14:24:10 +04:00
|
|
|
{
|
|
|
|
/* TODO: handle it somehow */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-06-20 17:29:44 +04:00
|
|
|
/* we never write there */
|
1998-02-27 07:54:42 +03:00
|
|
|
close (error_pipe[1]);
|
2009-06-20 17:29:44 +04:00
|
|
|
error_pipe[1] = -1;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
2012-08-31 18:05:29 +04:00
|
|
|
* Close a pipe
|
|
|
|
*
|
|
|
|
* @param error '-1' - ignore errors, '0' - display warning, '1' - display error
|
|
|
|
* @param text is prepended to the error message from the pipe
|
|
|
|
*
|
2012-11-05 17:57:50 +04:00
|
|
|
* @return not 0 if an error was displayed
|
1999-03-18 21:43:52 +03:00
|
|
|
*/
|
2010-11-08 13:21:45 +03:00
|
|
|
|
1999-03-18 21:43:52 +03:00
|
|
|
int
|
2004-08-30 03:20:01 +04:00
|
|
|
close_error_pipe (int error, const char *text)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2004-09-19 19:55:58 +04:00
|
|
|
const char *title;
|
1998-02-27 07:54:42 +03:00
|
|
|
char msg[MAX_PIPE_SIZE];
|
|
|
|
int len = 0;
|
|
|
|
|
2009-06-20 17:29:44 +04:00
|
|
|
/* already closed */
|
|
|
|
if (error_pipe[0] == -1)
|
2010-04-30 17:31:06 +04:00
|
|
|
return 0;
|
2009-06-20 17:29:44 +04:00
|
|
|
|
2011-10-23 11:08:24 +04:00
|
|
|
if (error < 0 || (error > 0 && (error & D_ERROR) != 0))
|
2010-04-30 17:31:06 +04:00
|
|
|
title = MSG_ERROR;
|
1998-02-27 07:54:42 +03:00
|
|
|
else
|
2010-04-30 17:31:06 +04:00
|
|
|
title = _("Warning");
|
|
|
|
if (old_error >= 0)
|
|
|
|
{
|
2013-12-20 11:26:56 +04:00
|
|
|
if (dup2 (old_error, STDERR_FILENO) == -1)
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
2011-10-23 11:08:24 +04:00
|
|
|
if (error < 0)
|
|
|
|
error = D_ERROR;
|
|
|
|
|
2010-05-15 18:45:13 +04:00
|
|
|
message (error, MSG_ERROR, _("Error dup'ing old error pipe"));
|
2010-04-30 17:31:06 +04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
close (old_error);
|
|
|
|
len = read (error_pipe[0], msg, MAX_PIPE_SIZE - 1);
|
|
|
|
|
|
|
|
if (len >= 0)
|
|
|
|
msg[len] = 0;
|
|
|
|
close (error_pipe[0]);
|
|
|
|
error_pipe[0] = -1;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
if (error < 0)
|
2010-04-30 17:31:06 +04:00
|
|
|
return 0; /* Just ignore error message */
|
|
|
|
if (text == NULL)
|
|
|
|
{
|
|
|
|
if (len <= 0)
|
|
|
|
return 0; /* Nothing to show */
|
|
|
|
|
|
|
|
/* Show message from pipe */
|
|
|
|
message (error, title, "%s", msg);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Show given text and possible message from pipe */
|
2010-05-15 18:45:13 +04:00
|
|
|
message (error, title, "%s\n%s", text, msg);
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
1999-03-18 21:43:52 +03:00
|
|
|
return 1;
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
2004-01-24 03:17:34 +03:00
|
|
|
* Canonicalize path, and return a new path. Do everything in place.
|
|
|
|
* The new path differs from path in:
|
2013-05-26 10:11:06 +04:00
|
|
|
* Multiple '/'s are collapsed to a single '/'.
|
|
|
|
* Leading './'s and trailing '/.'s are removed.
|
|
|
|
* Trailing '/'s are removed.
|
|
|
|
* Non-leading '../'s and trailing '..'s are handled by removing
|
2010-04-30 17:31:06 +04:00
|
|
|
* portions of the path.
|
2004-01-24 03:17:34 +03:00
|
|
|
* Well formed UNC paths are modified only in the local part.
|
|
|
|
*/
|
2010-11-08 13:21:45 +03:00
|
|
|
|
2004-01-24 02:53:37 +03:00
|
|
|
void
|
2009-11-23 11:45:46 +03:00
|
|
|
custom_canonicalize_pathname (char *path, CANON_PATH_FLAGS flags)
|
1998-02-27 07:54:42 +03:00
|
|
|
{
|
2003-03-10 09:52:57 +03:00
|
|
|
char *p, *s;
|
2010-04-30 17:31:06 +04:00
|
|
|
char *lpath = path; /* path without leading UNC part */
|
2011-06-14 16:09:59 +04:00
|
|
|
const size_t url_delim_len = strlen (VFS_PATH_URL_DELIMITER);
|
2004-01-24 03:17:34 +03:00
|
|
|
|
|
|
|
/* Detect and preserve UNC paths: //server/... */
|
2010-04-30 17:31:06 +04:00
|
|
|
if ((flags & CANON_PATH_GUARDUNC) && path[0] == PATH_SEP && path[1] == PATH_SEP)
|
|
|
|
{
|
|
|
|
p = path + 2;
|
|
|
|
while (p[0] && p[0] != '/')
|
|
|
|
p++;
|
|
|
|
if (p[0] == '/' && p > path + 2)
|
|
|
|
lpath = p;
|
2004-01-24 03:17:34 +03:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2004-01-24 03:17:34 +03:00
|
|
|
if (!lpath[0] || !lpath[1])
|
2010-04-30 17:31:06 +04:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (flags & CANON_PATH_JOINSLASHES)
|
|
|
|
{
|
|
|
|
/* Collapse multiple slashes */
|
|
|
|
p = lpath;
|
|
|
|
while (*p)
|
|
|
|
{
|
2011-06-07 17:35:17 +04:00
|
|
|
if (p[0] == PATH_SEP && p[1] == PATH_SEP && (p == lpath || *(p - 1) != ':'))
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
|
|
|
s = p + 1;
|
|
|
|
while (*(++s) == PATH_SEP);
|
|
|
|
str_move (p + 1, s);
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
2003-03-10 09:52:57 +03:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
if (flags & CANON_PATH_JOINSLASHES)
|
|
|
|
{
|
|
|
|
/* Collapse "/./" -> "/" */
|
|
|
|
p = lpath;
|
|
|
|
while (*p)
|
|
|
|
{
|
|
|
|
if (p[0] == PATH_SEP && p[1] == '.' && p[2] == PATH_SEP)
|
|
|
|
str_move (p, p + 2);
|
|
|
|
else
|
|
|
|
p++;
|
|
|
|
}
|
2003-03-10 09:52:57 +03:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
if (flags & CANON_PATH_REMSLASHDOTS)
|
|
|
|
{
|
2013-10-15 10:34:04 +04:00
|
|
|
size_t len;
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
/* Remove trailing slashes */
|
|
|
|
p = lpath + strlen (lpath) - 1;
|
|
|
|
while (p > lpath && *p == PATH_SEP)
|
2011-06-14 16:09:59 +04:00
|
|
|
{
|
|
|
|
if (p >= lpath - (url_delim_len + 1)
|
|
|
|
&& strncmp (p - url_delim_len + 1, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
|
|
|
|
break;
|
2010-04-30 17:31:06 +04:00
|
|
|
*p-- = 0;
|
2011-06-14 16:09:59 +04:00
|
|
|
}
|
2010-04-30 17:31:06 +04:00
|
|
|
|
|
|
|
/* Remove leading "./" */
|
|
|
|
if (lpath[0] == '.' && lpath[1] == PATH_SEP)
|
|
|
|
{
|
|
|
|
if (lpath[2] == 0)
|
|
|
|
{
|
|
|
|
lpath[1] = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
str_move (lpath, lpath + 2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remove trailing "/" or "/." */
|
|
|
|
len = strlen (lpath);
|
|
|
|
if (len < 2)
|
|
|
|
return;
|
2011-06-14 16:09:59 +04:00
|
|
|
if (lpath[len - 1] == PATH_SEP
|
|
|
|
&& (len < url_delim_len
|
|
|
|
|| strncmp (lpath + len - url_delim_len, VFS_PATH_URL_DELIMITER,
|
|
|
|
url_delim_len) != 0))
|
2010-04-30 17:31:06 +04:00
|
|
|
{
|
2011-06-14 16:09:59 +04:00
|
|
|
lpath[len - 1] = '\0';
|
2010-04-30 17:31:06 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (lpath[len - 1] == '.' && lpath[len - 2] == PATH_SEP)
|
|
|
|
{
|
|
|
|
if (len == 2)
|
|
|
|
{
|
2011-06-14 16:09:59 +04:00
|
|
|
lpath[1] = '\0';
|
2010-04-30 17:31:06 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-06-14 16:09:59 +04:00
|
|
|
lpath[len - 2] = '\0';
|
2010-04-30 17:31:06 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-11-23 11:45:46 +03:00
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
if (flags & CANON_PATH_REMDOUBLEDOTS)
|
|
|
|
{
|
2012-04-30 15:52:39 +04:00
|
|
|
#ifdef HAVE_CHARSET
|
2010-09-10 11:27:21 +04:00
|
|
|
const size_t enc_prefix_len = strlen (VFS_ENCODING_PREFIX);
|
2012-04-30 15:52:39 +04:00
|
|
|
#endif /* HAVE_CHARSET */
|
2010-09-10 11:27:21 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
/* Collapse "/.." with the previous part of path */
|
|
|
|
p = lpath;
|
|
|
|
while (p[0] && p[1] && p[2])
|
|
|
|
{
|
|
|
|
if ((p[0] != PATH_SEP || p[1] != '.' || p[2] != '.') || (p[3] != PATH_SEP && p[3] != 0))
|
|
|
|
{
|
|
|
|
p++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* search for the previous token */
|
|
|
|
s = p - 1;
|
2011-06-14 16:09:59 +04:00
|
|
|
if (s >= lpath + url_delim_len - 2
|
|
|
|
&& strncmp (s - url_delim_len + 2, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
|
|
|
|
{
|
|
|
|
s -= (url_delim_len - 2);
|
|
|
|
while (s >= lpath && *s-- != PATH_SEP);
|
|
|
|
}
|
|
|
|
|
2011-06-07 17:35:17 +04:00
|
|
|
while (s >= lpath)
|
|
|
|
{
|
2011-06-14 16:09:59 +04:00
|
|
|
if (s - url_delim_len > lpath
|
|
|
|
&& strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
|
2011-06-07 17:35:17 +04:00
|
|
|
{
|
2011-06-14 16:09:59 +04:00
|
|
|
char *vfs_prefix = s - url_delim_len;
|
|
|
|
struct vfs_class *vclass;
|
|
|
|
|
|
|
|
while (vfs_prefix > lpath && *--vfs_prefix != PATH_SEP);
|
|
|
|
if (*vfs_prefix == PATH_SEP)
|
|
|
|
vfs_prefix++;
|
|
|
|
*(s - url_delim_len) = '\0';
|
|
|
|
|
|
|
|
vclass = vfs_prefix_to_class (vfs_prefix);
|
|
|
|
*(s - url_delim_len) = *VFS_PATH_URL_DELIMITER;
|
|
|
|
|
|
|
|
if (vclass != NULL)
|
|
|
|
{
|
|
|
|
struct vfs_s_subclass *sub = (struct vfs_s_subclass *) vclass->data;
|
|
|
|
if (sub != NULL && sub->flags & VFS_S_REMOTE)
|
|
|
|
{
|
|
|
|
s = vfs_prefix;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2011-06-07 17:35:17 +04:00
|
|
|
}
|
2011-06-14 16:09:59 +04:00
|
|
|
|
2011-06-07 17:35:17 +04:00
|
|
|
if (*s == PATH_SEP)
|
2011-06-30 14:26:03 +04:00
|
|
|
break;
|
2011-06-14 02:32:15 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
s--;
|
2011-06-07 17:35:17 +04:00
|
|
|
}
|
2010-04-30 17:31:06 +04:00
|
|
|
|
|
|
|
s++;
|
|
|
|
|
|
|
|
/* If the previous token is "..", we cannot collapse it */
|
|
|
|
if (s[0] == '.' && s[1] == '.' && s + 2 == p)
|
|
|
|
{
|
|
|
|
p += 3;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p[3] != 0)
|
|
|
|
{
|
|
|
|
if (s == lpath && *s == PATH_SEP)
|
|
|
|
{
|
|
|
|
/* "/../foo" -> "/foo" */
|
|
|
|
str_move (s + 1, p + 4);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* "token/../foo" -> "foo" */
|
2012-02-06 21:43:01 +04:00
|
|
|
#ifdef HAVE_CHARSET
|
2010-09-13 13:32:27 +04:00
|
|
|
if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
|
|
|
|
&& (is_supported_encoding (s + enc_prefix_len)))
|
2010-09-10 11:27:21 +04:00
|
|
|
/* special case: remove encoding */
|
2010-09-09 16:50:26 +04:00
|
|
|
str_move (s, p + 1);
|
|
|
|
else
|
|
|
|
#endif /* HAVE_CHARSET */
|
|
|
|
str_move (s, p + 4);
|
2010-04-30 17:31:06 +04:00
|
|
|
}
|
|
|
|
p = (s > lpath) ? s - 1 : s;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* trailing ".." */
|
|
|
|
if (s == lpath)
|
|
|
|
{
|
|
|
|
/* "token/.." -> "." */
|
|
|
|
if (lpath[0] != PATH_SEP)
|
|
|
|
{
|
|
|
|
lpath[0] = '.';
|
|
|
|
}
|
|
|
|
lpath[1] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* "foo/token/.." -> "foo" */
|
|
|
|
if (s == lpath + 1)
|
|
|
|
s[0] = 0;
|
2012-02-06 21:43:01 +04:00
|
|
|
#ifdef HAVE_CHARSET
|
2010-09-13 13:32:27 +04:00
|
|
|
else if ((strncmp (s, VFS_ENCODING_PREFIX, enc_prefix_len) == 0)
|
2010-11-08 13:21:45 +03:00
|
|
|
&& (is_supported_encoding (s + enc_prefix_len)))
|
2010-09-09 16:50:26 +04:00
|
|
|
{
|
|
|
|
/* special case: remove encoding */
|
|
|
|
s[0] = '.';
|
|
|
|
s[1] = '.';
|
|
|
|
s[2] = '\0';
|
|
|
|
|
|
|
|
/* search for the previous token */
|
|
|
|
/* s[-1] == PATH_SEP */
|
|
|
|
p = s - 1;
|
|
|
|
while (p >= lpath && *p != PATH_SEP)
|
|
|
|
p--;
|
|
|
|
|
2013-09-20 13:13:56 +04:00
|
|
|
if (p >= lpath)
|
2010-09-09 16:50:26 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif /* HAVE_CHARSET */
|
2010-04-30 17:31:06 +04:00
|
|
|
else
|
2011-06-14 16:09:59 +04:00
|
|
|
{
|
|
|
|
if (s >= lpath + url_delim_len
|
|
|
|
&& strncmp (s - url_delim_len, VFS_PATH_URL_DELIMITER, url_delim_len) == 0)
|
|
|
|
*s = '\0';
|
|
|
|
else
|
|
|
|
s[-1] = '\0';
|
|
|
|
}
|
2010-04-30 17:31:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
1998-02-27 07:54:42 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2009-11-23 11:45:46 +03:00
|
|
|
void
|
|
|
|
canonicalize_pathname (char *path)
|
|
|
|
{
|
|
|
|
custom_canonicalize_pathname (path, CANON_PATH_ALL);
|
|
|
|
}
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2002-07-30 03:12:31 +04:00
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
#ifdef HAVE_GET_PROCESS_STATS
|
2010-04-30 17:31:06 +04:00
|
|
|
int
|
|
|
|
gettimeofday (struct timeval *tp, void *tzp)
|
2002-07-30 03:12:31 +04:00
|
|
|
{
|
2010-04-30 17:31:06 +04:00
|
|
|
return get_process_stats (tp, PS_SELF, 0, 0);
|
2002-07-30 03:12:31 +04:00
|
|
|
}
|
|
|
|
#endif /* HAVE_GET_PROCESS_STATS */
|
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
|
2010-05-13 21:28:12 +04:00
|
|
|
#ifndef HAVE_REALPATH
|
2005-01-13 22:37:46 +03:00
|
|
|
char *
|
2010-05-13 21:28:12 +04:00
|
|
|
mc_realpath (const char *path, char *resolved_path)
|
2005-01-13 22:37:46 +03:00
|
|
|
{
|
|
|
|
char copy_path[PATH_MAX];
|
|
|
|
char link_path[PATH_MAX];
|
|
|
|
char got_path[PATH_MAX];
|
|
|
|
char *new_path = got_path;
|
|
|
|
char *max_path;
|
|
|
|
int readlinks = 0;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
/* Make a copy of the source path since we may need to modify it. */
|
2010-04-30 17:31:06 +04:00
|
|
|
if (strlen (path) >= PATH_MAX - 2)
|
|
|
|
{
|
|
|
|
errno = ENAMETOOLONG;
|
|
|
|
return NULL;
|
2005-01-13 22:37:46 +03:00
|
|
|
}
|
|
|
|
strcpy (copy_path, path);
|
|
|
|
path = copy_path;
|
|
|
|
max_path = copy_path + PATH_MAX - 2;
|
|
|
|
/* If it's a relative pathname use getwd for starters. */
|
2010-04-30 17:31:06 +04:00
|
|
|
if (*path != '/')
|
|
|
|
{
|
|
|
|
|
|
|
|
new_path = g_get_current_dir ();
|
|
|
|
if (new_path == NULL)
|
|
|
|
{
|
|
|
|
strcpy (got_path, "");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_snprintf (got_path, PATH_MAX, "%s", new_path);
|
|
|
|
g_free (new_path);
|
2009-12-29 01:53:09 +03:00
|
|
|
new_path = got_path;
|
2010-04-30 17:31:06 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
new_path += strlen (got_path);
|
|
|
|
if (new_path[-1] != '/')
|
|
|
|
*new_path++ = '/';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
*new_path++ = '/';
|
|
|
|
path++;
|
2005-01-13 22:37:46 +03:00
|
|
|
}
|
|
|
|
/* Expand each slash-separated pathname component. */
|
2010-04-30 17:31:06 +04:00
|
|
|
while (*path != '\0')
|
|
|
|
{
|
|
|
|
/* Ignore stray "/". */
|
|
|
|
if (*path == '/')
|
|
|
|
{
|
|
|
|
path++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (*path == '.')
|
|
|
|
{
|
|
|
|
/* Ignore ".". */
|
|
|
|
if (path[1] == '\0' || path[1] == '/')
|
|
|
|
{
|
|
|
|
path++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (path[1] == '.')
|
|
|
|
{
|
|
|
|
if (path[2] == '\0' || path[2] == '/')
|
|
|
|
{
|
|
|
|
path += 2;
|
|
|
|
/* Ignore ".." at root. */
|
|
|
|
if (new_path == got_path + 1)
|
|
|
|
continue;
|
|
|
|
/* Handle ".." by backing up. */
|
|
|
|
while ((--new_path)[-1] != '/');
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Safely copy the next pathname component. */
|
|
|
|
while (*path != '\0' && *path != '/')
|
|
|
|
{
|
|
|
|
if (path > max_path)
|
|
|
|
{
|
|
|
|
errno = ENAMETOOLONG;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
*new_path++ = *path++;
|
|
|
|
}
|
2005-01-13 22:37:46 +03:00
|
|
|
#ifdef S_IFLNK
|
2010-04-30 17:31:06 +04:00
|
|
|
/* Protect against infinite loops. */
|
|
|
|
if (readlinks++ > MAXSYMLINKS)
|
|
|
|
{
|
|
|
|
errno = ELOOP;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* See if latest pathname component is a symlink. */
|
|
|
|
*new_path = '\0';
|
|
|
|
n = readlink (got_path, link_path, PATH_MAX - 1);
|
|
|
|
if (n < 0)
|
|
|
|
{
|
|
|
|
/* EINVAL means the file exists but isn't a symlink. */
|
|
|
|
if (errno != EINVAL)
|
|
|
|
{
|
|
|
|
/* Make sure it's null terminated. */
|
|
|
|
*new_path = '\0';
|
|
|
|
strcpy (resolved_path, got_path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Note: readlink doesn't add the null byte. */
|
|
|
|
link_path[n] = '\0';
|
|
|
|
if (*link_path == '/')
|
|
|
|
/* Start over for an absolute symlink. */
|
|
|
|
new_path = got_path;
|
|
|
|
else
|
|
|
|
/* Otherwise back up over this component. */
|
|
|
|
while (*(--new_path) != '/');
|
|
|
|
/* Safe sex check. */
|
|
|
|
if (strlen (path) + n >= PATH_MAX - 2)
|
|
|
|
{
|
|
|
|
errno = ENAMETOOLONG;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
/* Insert symlink contents into path. */
|
|
|
|
strcat (link_path, path);
|
|
|
|
strcpy (copy_path, link_path);
|
|
|
|
path = copy_path;
|
|
|
|
}
|
|
|
|
#endif /* S_IFLNK */
|
|
|
|
*new_path++ = '/';
|
2005-01-13 22:37:46 +03:00
|
|
|
}
|
|
|
|
/* Delete trailing slash but don't whomp a lone slash. */
|
|
|
|
if (new_path != got_path + 1 && new_path[-1] == '/')
|
2010-04-30 17:31:06 +04:00
|
|
|
new_path--;
|
2005-01-13 22:37:46 +03:00
|
|
|
/* Make sure it's null terminated. */
|
|
|
|
*new_path = '\0';
|
|
|
|
strcpy (resolved_path, got_path);
|
|
|
|
return resolved_path;
|
|
|
|
}
|
2010-05-13 21:28:12 +04:00
|
|
|
#endif /* HAVE_REALPATH */
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-11-08 13:21:45 +03:00
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
|
|
* Return the index of the permissions triplet
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2005-07-23 01:16:50 +04:00
|
|
|
int
|
2010-04-30 17:31:06 +04:00
|
|
|
get_user_permissions (struct stat *st)
|
|
|
|
{
|
2009-02-06 01:46:07 +03:00
|
|
|
static gboolean initialized = FALSE;
|
2005-07-23 01:16:50 +04:00
|
|
|
static gid_t *groups;
|
|
|
|
static int ngroups;
|
|
|
|
static uid_t uid;
|
|
|
|
int i;
|
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
if (!initialized)
|
|
|
|
{
|
|
|
|
uid = geteuid ();
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
ngroups = getgroups (0, NULL);
|
|
|
|
if (ngroups == -1)
|
|
|
|
ngroups = 0; /* ignore errors */
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
/* allocate space for one element in addition to what
|
|
|
|
* will be filled by getgroups(). */
|
|
|
|
groups = g_new (gid_t, ngroups + 1);
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
if (ngroups != 0)
|
|
|
|
{
|
|
|
|
ngroups = getgroups (ngroups, groups);
|
|
|
|
if (ngroups == -1)
|
|
|
|
ngroups = 0; /* ignore errors */
|
|
|
|
}
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
/* getgroups() may or may not return the effective group ID,
|
|
|
|
* so we always include it at the end of the list. */
|
|
|
|
groups[ngroups++] = getegid ();
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
initialized = TRUE;
|
2005-07-23 01:16:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (st->st_uid == uid || uid == 0)
|
2010-04-30 17:31:06 +04:00
|
|
|
return 0;
|
2005-07-23 01:16:50 +04:00
|
|
|
|
2010-04-30 17:31:06 +04:00
|
|
|
for (i = 0; i < ngroups; i++)
|
|
|
|
{
|
|
|
|
if (st->st_gid == groups[i])
|
|
|
|
return 1;
|
2005-07-23 01:16:50 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
}
|
2010-11-08 13:21:45 +03:00
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2011-06-17 21:17:16 +04:00
|
|
|
/**
|
|
|
|
* Build filename from arguments.
|
|
|
|
* Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
|
|
|
|
*/
|
|
|
|
|
|
|
|
char *
|
2011-07-17 20:59:47 +04:00
|
|
|
mc_build_filenamev (const char *first_element, va_list args)
|
2011-06-17 21:17:16 +04:00
|
|
|
{
|
2011-09-20 09:21:11 +04:00
|
|
|
gboolean absolute;
|
2011-06-17 21:17:16 +04:00
|
|
|
const char *element = first_element;
|
|
|
|
GString *path;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
if (element == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
path = g_string_new ("");
|
|
|
|
|
2011-09-20 09:21:11 +04:00
|
|
|
absolute = (*first_element != '\0' && *first_element == PATH_SEP);
|
|
|
|
|
2011-06-17 21:17:16 +04:00
|
|
|
do
|
|
|
|
{
|
2011-09-19 14:43:05 +04:00
|
|
|
if (*element == '\0')
|
|
|
|
element = va_arg (args, char *);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
char *tmp_element;
|
|
|
|
size_t len;
|
|
|
|
const char *start;
|
2011-06-17 21:17:16 +04:00
|
|
|
|
2011-09-19 14:43:05 +04:00
|
|
|
tmp_element = g_strdup (element);
|
2011-06-17 21:17:16 +04:00
|
|
|
|
2011-09-19 14:43:05 +04:00
|
|
|
element = va_arg (args, char *);
|
2011-06-17 21:17:16 +04:00
|
|
|
|
2011-09-19 14:43:05 +04:00
|
|
|
canonicalize_pathname (tmp_element);
|
|
|
|
len = strlen (tmp_element);
|
|
|
|
start = (tmp_element[0] == PATH_SEP) ? tmp_element + 1 : tmp_element;
|
2011-06-17 21:17:16 +04:00
|
|
|
|
2011-09-19 14:43:05 +04:00
|
|
|
g_string_append (path, start);
|
|
|
|
if (tmp_element[len - 1] != PATH_SEP && element != NULL)
|
|
|
|
g_string_append_c (path, PATH_SEP);
|
2011-06-17 21:17:16 +04:00
|
|
|
|
2011-09-19 14:43:05 +04:00
|
|
|
g_free (tmp_element);
|
|
|
|
}
|
2011-06-17 21:17:16 +04:00
|
|
|
}
|
|
|
|
while (element != NULL);
|
|
|
|
|
2011-09-20 09:21:11 +04:00
|
|
|
if (absolute)
|
|
|
|
g_string_prepend_c (path, PATH_SEP);
|
2011-06-17 21:17:16 +04:00
|
|
|
|
|
|
|
ret = g_string_free (path, FALSE);
|
|
|
|
canonicalize_pathname (ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|
2011-07-17 20:59:47 +04:00
|
|
|
/**
|
|
|
|
* Build filename from arguments.
|
|
|
|
* Like to g_build_filename(), but respect VFS_PATH_URL_DELIMITER
|
|
|
|
*/
|
|
|
|
|
|
|
|
char *
|
|
|
|
mc_build_filename (const char *first_element, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
if (first_element == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
va_start (args, first_element);
|
|
|
|
ret = mc_build_filenamev (first_element, args);
|
|
|
|
va_end (args);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------------------------------- */
|