1 /* Various utilities - Unix variants
2 Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2007 Free Software Foundation, Inc.
4 Written 1994, 1995, 1996 by:
5 Miguel de Icaza, Janne Kukonlehto, Dugan Porter,
6 Jakub Jelinek, Mauricio Plaza.
8 The mc_realpath routine is mostly from uClibc package, written
9 by Rick Sladkey <jrs@world.std.com>
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
26 * \brief Source: various utilities - Unix variant
40 #include <sys/param.h>
41 #include <sys/types.h>
44 #ifdef HAVE_SYS_IOCTL_H
45 #include <sys/ioctl.h>
47 #ifdef HAVE_GET_PROCESS_STATS
48 #include <sys/procstats.h>
54 #include "lib/global.h"
55 #include "lib/vfs/vfs.h" /* VFS_ENCODING_PREFIX */
56 #include "lib/strutil.h" /* str_move() */
58 #include "lib/widget.h" /* message() */
61 #include "lib/charsets.h"
66 /*** global variables ****************************************************************************/
68 struct sigaction startup_handler
;
70 /*** file scope macro definitions ****************************************************************/
72 #define UID_CACHE_SIZE 200
73 #define GID_CACHE_SIZE 30
75 /* Pipes are guaranteed to be able to hold at least 4096 bytes */
76 /* More than that would be unportable */
77 #define MAX_PIPE_SIZE 4096
79 /*** file scope type declarations ****************************************************************/
87 /*** file scope variables ************************************************************************/
89 static int_cache uid_cache
[UID_CACHE_SIZE
];
90 static int_cache gid_cache
[GID_CACHE_SIZE
];
92 static int error_pipe
[2]; /* File descriptors of error pipe */
93 static int old_error
; /* File descriptor of old standard error */
95 /*** file scope functions ************************************************************************/
96 /* --------------------------------------------------------------------------------------------- */
99 i_cache_match (int id
, int_cache
* cache
, int size
)
103 for (i
= 0; i
< size
; i
++)
104 if (cache
[i
].index
== id
)
105 return cache
[i
].string
;
109 /* --------------------------------------------------------------------------------------------- */
112 i_cache_add (int id
, int_cache
* cache
, int size
, char *text
, int *last
)
114 g_free (cache
[*last
].string
);
115 cache
[*last
].string
= g_strdup (text
);
116 cache
[*last
].index
= id
;
117 *last
= ((*last
) + 1) % size
;
120 /* --------------------------------------------------------------------------------------------- */
121 /*** public functions ****************************************************************************/
122 /* --------------------------------------------------------------------------------------------- */
128 static char ibuf
[10];
132 name
= i_cache_match (uid
, uid_cache
, UID_CACHE_SIZE
);
136 pwd
= getpwuid (uid
);
139 i_cache_add (uid
, uid_cache
, UID_CACHE_SIZE
, pwd
->pw_name
, &uid_last
);
144 g_snprintf (ibuf
, sizeof (ibuf
), "%d", uid
);
149 /* --------------------------------------------------------------------------------------------- */
155 static char gbuf
[10];
159 name
= i_cache_match (gid
, gid_cache
, GID_CACHE_SIZE
);
163 grp
= getgrgid (gid
);
166 i_cache_add (gid
, gid_cache
, GID_CACHE_SIZE
, grp
->gr_name
, &gid_last
);
171 g_snprintf (gbuf
, sizeof (gbuf
), "%d", gid
);
176 /* --------------------------------------------------------------------------------------------- */
177 /* Since ncurses uses a handler that automatically refreshes the */
178 /* screen after a SIGCONT, and we don't want this behavior when */
179 /* spawning a child, we save the original handler here */
182 save_stop_handler (void)
184 sigaction (SIGTSTP
, NULL
, &startup_handler
);
187 /* --------------------------------------------------------------------------------------------- */
190 my_system (int flags
, const char *shell
, const char *command
)
192 struct sigaction ignore
, save_intr
, save_quit
, save_stop
;
196 ignore
.sa_handler
= SIG_IGN
;
197 sigemptyset (&ignore
.sa_mask
);
200 sigaction (SIGINT
, &ignore
, &save_intr
);
201 sigaction (SIGQUIT
, &ignore
, &save_quit
);
203 /* Restore the original SIGTSTP handler, we don't want ncurses' */
204 /* handler messing the screen after the SIGCONT */
205 sigaction (SIGTSTP
, &startup_handler
, &save_stop
);
210 fprintf (stderr
, "\n\nfork () = -1\n");
215 signal (SIGINT
, SIG_DFL
);
216 signal (SIGQUIT
, SIG_DFL
);
217 signal (SIGTSTP
, SIG_DFL
);
218 signal (SIGCHLD
, SIG_DFL
);
220 if (flags
& EXECUTE_AS_SHELL
)
221 execl (shell
, shell
, "-c", command
, (char *) NULL
);
224 gchar
**shell_tokens
;
225 const gchar
*only_cmd
;
227 shell_tokens
= g_strsplit (shell
, " ", 2);
228 if (shell_tokens
== NULL
)
231 only_cmd
= (*shell_tokens
!= NULL
) ? *shell_tokens
: shell
;
233 execlp (only_cmd
, shell
, command
, (char *) NULL
);
236 execlp will replace current process,
237 therefore no sence in call of g_strfreev().
238 But this keeped for estetic reason :)
240 g_strfreev (shell_tokens
);
244 _exit (127); /* Exec error */
250 if (waitpid (pid
, &status
, 0) > 0)
252 status
= WEXITSTATUS (status
);
262 sigaction (SIGINT
, &save_intr
, NULL
);
263 sigaction (SIGQUIT
, &save_quit
, NULL
);
264 sigaction (SIGTSTP
, &save_stop
, NULL
);
270 /* --------------------------------------------------------------------------------------------- */
272 * Perform tilde expansion if possible.
273 * Always return a newly allocated string, even if it's unchanged.
277 tilde_expand (const char *directory
)
279 struct passwd
*passwd
;
283 if (*directory
!= '~')
284 return g_strdup (directory
);
288 /* d = "~" or d = "~/" */
289 if (!(*p
) || (*p
== PATH_SEP
))
291 passwd
= getpwuid (geteuid ());
292 q
= (*p
== PATH_SEP
) ? p
+ 1 : "";
296 q
= strchr (p
, PATH_SEP
);
299 passwd
= getpwnam (p
);
303 name
= g_strndup (p
, q
- p
);
304 passwd
= getpwnam (name
);
310 /* If we can't figure the user name, leave tilde unexpanded */
312 return g_strdup (directory
);
314 return g_strconcat (passwd
->pw_dir
, PATH_SEP_STR
, q
, (char *) NULL
);
317 /* --------------------------------------------------------------------------------------------- */
319 * Return the directory where mc should keep its temporary files.
320 * This directory is (in Bourne shell terms) "${TMPDIR=/tmp}/mc-$USER"
321 * When called the first time, the directory is created if needed.
322 * The first call should be done early, since we are using fprintf()
323 * and not message() to report possible problems.
329 static char buffer
[64];
330 static const char *tmpdir
;
334 const char *error
= NULL
;
336 /* Check if already correctly initialized */
337 if (tmpdir
&& lstat (tmpdir
, &st
) == 0 && S_ISDIR (st
.st_mode
) &&
338 st
.st_uid
== getuid () && (st
.st_mode
& 0777) == 0700)
341 sys_tmp
= getenv ("TMPDIR");
342 if (!sys_tmp
|| sys_tmp
[0] != '/')
344 sys_tmp
= TMPDIR_DEFAULT
;
347 pwd
= getpwuid (getuid ());
350 g_snprintf (buffer
, sizeof (buffer
), "%s/mc-%s", sys_tmp
, pwd
->pw_name
);
352 g_snprintf (buffer
, sizeof (buffer
), "%s/mc-%lu", sys_tmp
, (unsigned long) getuid ());
354 canonicalize_pathname (buffer
);
356 if (lstat (buffer
, &st
) == 0)
358 /* Sanity check for existing directory */
359 if (!S_ISDIR (st
.st_mode
))
360 error
= _("%s is not a directory\n");
361 else if (st
.st_uid
!= getuid ())
362 error
= _("Directory %s is not owned by you\n");
363 else if (((st
.st_mode
& 0777) != 0700) && (chmod (buffer
, 0700) != 0))
364 error
= _("Cannot set correct permissions for directory %s\n");
368 /* Need to create directory */
369 if (mkdir (buffer
, S_IRWXU
) != 0)
372 _("Cannot create temporary directory %s: %s\n"),
373 buffer
, unix_error_string (errno
));
381 char *test_fn
, *fallback_prefix
;
385 fprintf (stderr
, error
, buffer
);
387 /* Test if sys_tmp is suitable for temporary files */
388 fallback_prefix
= g_strdup_printf ("%s/mctest", sys_tmp
);
389 test_fd
= mc_mkstemps (&test_fn
, fallback_prefix
, NULL
);
390 g_free (fallback_prefix
);
394 test_fd
= open (test_fn
, O_RDONLY
);
405 fprintf (stderr
, _("Temporary files will be created in %s\n"), sys_tmp
);
406 g_snprintf (buffer
, sizeof (buffer
), "%s", sys_tmp
);
411 fprintf (stderr
, _("Temporary files will not be created\n"));
412 g_snprintf (buffer
, sizeof (buffer
), "%s", "/dev/null/");
415 fprintf (stderr
, "%s\n", _("Press any key to continue..."));
422 g_setenv ("MC_TMPDIR", tmpdir
, TRUE
);
427 /* --------------------------------------------------------------------------------------------- */
429 * Creates a pipe to hold standard error for a later analysis.
430 * The pipe can hold 4096 bytes. Make sure no more is written
431 * or a deadlock might occur.
435 open_error_pipe (void)
437 if (pipe (error_pipe
) < 0)
439 message (D_NORMAL
, _("Warning"), _("Pipe failed"));
442 if (old_error
< 0 || close (2) || dup (error_pipe
[1]) != 2)
444 message (D_NORMAL
, _("Warning"), _("Dup failed"));
446 close (error_pipe
[0]);
452 * Settng stderr in nonblocking mode as we close it earlier, than
453 * program stops. We try to read some error at program startup,
454 * but we should not block on it.
456 * TODO: make piped stdin/stderr poll()/select()able to get rid
460 fd_flags
= fcntl (error_pipe
[0], F_GETFL
, NULL
);
463 fd_flags
|= O_NONBLOCK
;
464 if (fcntl (error_pipe
[0], F_SETFL
, fd_flags
) == -1)
466 /* TODO: handle it somehow */
470 /* we never write there */
471 close (error_pipe
[1]);
475 /* --------------------------------------------------------------------------------------------- */
477 * Returns true if an error was displayed
478 * error: -1 - ignore errors, 0 - display warning, 1 - display error
479 * text is prepended to the error message from the pipe
483 close_error_pipe (int error
, const char *text
)
486 char msg
[MAX_PIPE_SIZE
];
490 if (error_pipe
[0] == -1)
496 title
= _("Warning");
499 if (dup2 (old_error
, 2) == -1)
501 message (error
, MSG_ERROR
, _("Error dup'ing old error pipe"));
505 len
= read (error_pipe
[0], msg
, MAX_PIPE_SIZE
- 1);
509 close (error_pipe
[0]);
513 return 0; /* Just ignore error message */
517 return 0; /* Nothing to show */
519 /* Show message from pipe */
520 message (error
, title
, "%s", msg
);
524 /* Show given text and possible message from pipe */
525 message (error
, title
, "%s\n%s", text
, msg
);
530 /* --------------------------------------------------------------------------------------------- */
532 * Canonicalize path, and return a new path. Do everything in place.
533 * The new path differs from path in:
534 * Multiple `/'s are collapsed to a single `/'.
535 * Leading `./'s and trailing `/.'s are removed.
536 * Trailing `/'s are removed.
537 * Non-leading `../'s and trailing `..'s are handled by removing
538 * portions of the path.
539 * Well formed UNC paths are modified only in the local part.
543 custom_canonicalize_pathname (char *path
, CANON_PATH_FLAGS flags
)
547 char *lpath
= path
; /* path without leading UNC part */
549 /* Detect and preserve UNC paths: //server/... */
550 if ((flags
& CANON_PATH_GUARDUNC
) && path
[0] == PATH_SEP
&& path
[1] == PATH_SEP
)
553 while (p
[0] && p
[0] != '/')
555 if (p
[0] == '/' && p
> path
+ 2)
559 if (!lpath
[0] || !lpath
[1])
562 if (flags
& CANON_PATH_JOINSLASHES
)
564 /* Collapse multiple slashes */
568 if (p
[0] == PATH_SEP
&& p
[1] == PATH_SEP
&& (p
== lpath
|| *(p
- 1) != ':'))
571 while (*(++s
) == PATH_SEP
);
578 if (flags
& CANON_PATH_JOINSLASHES
)
580 /* Collapse "/./" -> "/" */
584 if (p
[0] == PATH_SEP
&& p
[1] == '.' && p
[2] == PATH_SEP
)
591 if (flags
& CANON_PATH_REMSLASHDOTS
)
593 /* Remove trailing slashes */
594 p
= lpath
+ strlen (lpath
) - 1;
595 while (p
> lpath
&& *p
== PATH_SEP
)
598 /* Remove leading "./" */
599 if (lpath
[0] == '.' && lpath
[1] == PATH_SEP
)
608 str_move (lpath
, lpath
+ 2);
612 /* Remove trailing "/" or "/." */
613 len
= strlen (lpath
);
616 if (lpath
[len
- 1] == PATH_SEP
)
622 if (lpath
[len
- 1] == '.' && lpath
[len
- 2] == PATH_SEP
)
637 if (flags
& CANON_PATH_REMDOUBLEDOTS
)
639 const size_t enc_prefix_len
= strlen (VFS_ENCODING_PREFIX
);
641 /* Collapse "/.." with the previous part of path */
643 while (p
[0] && p
[1] && p
[2])
645 if ((p
[0] != PATH_SEP
|| p
[1] != '.' || p
[2] != '.') || (p
[3] != PATH_SEP
&& p
[3] != 0))
651 /* search for the previous token */
655 if (s
>= lpath
+ 2 && strncmp (s
- 2, "://", 3) == 0)
667 /* If the previous token is "..", we cannot collapse it */
668 if (s
[0] == '.' && s
[1] == '.' && s
+ 2 == p
)
676 if (s
== lpath
&& *s
== PATH_SEP
)
678 /* "/../foo" -> "/foo" */
679 str_move (s
+ 1, p
+ 4);
683 /* "token/../foo" -> "foo" */
685 if ((strncmp (s
, VFS_ENCODING_PREFIX
, enc_prefix_len
) == 0)
686 && (is_supported_encoding (s
+ enc_prefix_len
)))
687 /* special case: remove encoding */
690 #endif /* HAVE_CHARSET */
693 p
= (s
> lpath
) ? s
- 1 : s
;
700 /* "token/.." -> "." */
701 if (lpath
[0] != PATH_SEP
)
709 /* "foo/token/.." -> "foo" */
713 else if ((strncmp (s
, VFS_ENCODING_PREFIX
, enc_prefix_len
) == 0)
714 && (is_supported_encoding (s
+ enc_prefix_len
)))
716 /* special case: remove encoding */
721 /* search for the previous token */
722 /* s[-1] == PATH_SEP */
724 while (p
>= lpath
&& *p
!= PATH_SEP
)
730 #endif /* HAVE_CHARSET */
741 /* --------------------------------------------------------------------------------------------- */
744 canonicalize_pathname (char *path
)
746 custom_canonicalize_pathname (path
, CANON_PATH_ALL
);
749 /* --------------------------------------------------------------------------------------------- */
751 #ifdef HAVE_GET_PROCESS_STATS
753 gettimeofday (struct timeval
*tp
, void *tzp
)
755 return get_process_stats (tp
, PS_SELF
, 0, 0);
757 #endif /* HAVE_GET_PROCESS_STATS */
759 /* --------------------------------------------------------------------------------------------- */
761 #ifndef HAVE_REALPATH
763 mc_realpath (const char *path
, char *resolved_path
)
765 char copy_path
[PATH_MAX
];
766 char link_path
[PATH_MAX
];
767 char got_path
[PATH_MAX
];
768 char *new_path
= got_path
;
773 /* Make a copy of the source path since we may need to modify it. */
774 if (strlen (path
) >= PATH_MAX
- 2)
776 errno
= ENAMETOOLONG
;
779 strcpy (copy_path
, path
);
781 max_path
= copy_path
+ PATH_MAX
- 2;
782 /* If it's a relative pathname use getwd for starters. */
786 new_path
= g_get_current_dir ();
787 if (new_path
== NULL
)
789 strcpy (got_path
, "");
793 g_snprintf (got_path
, PATH_MAX
, "%s", new_path
);
798 new_path
+= strlen (got_path
);
799 if (new_path
[-1] != '/')
807 /* Expand each slash-separated pathname component. */
808 while (*path
!= '\0')
810 /* Ignore stray "/". */
819 if (path
[1] == '\0' || path
[1] == '/')
826 if (path
[2] == '\0' || path
[2] == '/')
829 /* Ignore ".." at root. */
830 if (new_path
== got_path
+ 1)
832 /* Handle ".." by backing up. */
833 while ((--new_path
)[-1] != '/');
838 /* Safely copy the next pathname component. */
839 while (*path
!= '\0' && *path
!= '/')
843 errno
= ENAMETOOLONG
;
846 *new_path
++ = *path
++;
849 /* Protect against infinite loops. */
850 if (readlinks
++ > MAXSYMLINKS
)
855 /* See if latest pathname component is a symlink. */
857 n
= readlink (got_path
, link_path
, PATH_MAX
- 1);
860 /* EINVAL means the file exists but isn't a symlink. */
863 /* Make sure it's null terminated. */
865 strcpy (resolved_path
, got_path
);
871 /* Note: readlink doesn't add the null byte. */
873 if (*link_path
== '/')
874 /* Start over for an absolute symlink. */
877 /* Otherwise back up over this component. */
878 while (*(--new_path
) != '/');
879 /* Safe sex check. */
880 if (strlen (path
) + n
>= PATH_MAX
- 2)
882 errno
= ENAMETOOLONG
;
885 /* Insert symlink contents into path. */
886 strcat (link_path
, path
);
887 strcpy (copy_path
, link_path
);
893 /* Delete trailing slash but don't whomp a lone slash. */
894 if (new_path
!= got_path
+ 1 && new_path
[-1] == '/')
896 /* Make sure it's null terminated. */
898 strcpy (resolved_path
, got_path
);
899 return resolved_path
;
901 #endif /* HAVE_REALPATH */
903 /* --------------------------------------------------------------------------------------------- */
905 * Return the index of the permissions triplet
910 get_user_permissions (struct stat
*st
)
912 static gboolean initialized
= FALSE
;
913 static gid_t
*groups
;
922 ngroups
= getgroups (0, NULL
);
924 ngroups
= 0; /* ignore errors */
926 /* allocate space for one element in addition to what
927 * will be filled by getgroups(). */
928 groups
= g_new (gid_t
, ngroups
+ 1);
932 ngroups
= getgroups (ngroups
, groups
);
934 ngroups
= 0; /* ignore errors */
937 /* getgroups() may or may not return the effective group ID,
938 * so we always include it at the end of the list. */
939 groups
[ngroups
++] = getegid ();
944 if (st
->st_uid
== uid
|| uid
== 0)
947 for (i
= 0; i
< ngroups
; i
++)
949 if (st
->st_gid
== groups
[i
])
956 /* --------------------------------------------------------------------------------------------- */