1 /* general.c -- Stuff that is used by all files. */
3 /* Copyright (C) 1987-2011 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #include "bashtypes.h"
24 #if defined (HAVE_SYS_PARAM_H)
25 # include <sys/param.h>
27 #include "posixstat.h"
29 #if defined (HAVE_UNISTD_H)
36 #include "chartypes.h"
45 #include <tilde/tilde.h>
51 extern int expand_aliases;
52 extern int interactive_comments;
53 extern int check_hashed_filenames;
54 extern int source_uses_path;
55 extern int source_searches_cwd;
57 static char *bash_special_tilde_expansions __P((char *));
58 static int unquoted_tilde_word __P((const char *));
59 static void initialize_group_array __P((void));
61 /* A standard error message to use when getcwd() returns NULL. */
62 const char * const bash_getcwd_errstr = N_("getcwd: cannot access parent directories");
64 /* Do whatever is necessary to initialize `Posix mode'. */
69 /* Things that should be turned on when posix mode is enabled. */
72 interactive_comments = source_uses_path = expand_aliases = 1;
73 source_searches_cwd = 0;
76 /* Things that should be turned on when posix mode is disabled. */
79 source_searches_cwd = 1;
80 expand_aliases = interactive_shell;
84 /* **************************************************************** */
86 /* Functions to convert to and from and display non-standard types */
88 /* **************************************************************** */
90 #if defined (RLIMTYPE)
92 string_to_rlimtype (s)
100 while (s && *s && whitespace (*s))
102 if (s && (*s == '-' || *s == '+'))
107 for ( ; s && *s && DIGIT (*s); s++)
108 ret = (ret * 10) + TODIGIT (*s);
109 return (neg ? -ret : ret);
113 print_rlimtype (n, addnl)
117 char s[INT_STRLEN_BOUND (RLIMTYPE) + 1], *p;
126 while ((n /= 10) != 0);
134 while ((n /= 10) != 0);
137 printf ("%s%s", p, addnl ? "\n" : "");
139 #endif /* RLIMTYPE */
141 /* **************************************************************** */
143 /* Input Validation Functions */
145 /* **************************************************************** */
147 /* Return non-zero if all of the characters in STRING are digits. */
154 for (s = string; *s; s++)
161 /* Return non-zero if the characters pointed to by STRING constitute a
162 valid number. Stuff the converted number into RESULT if RESULT is
165 legal_number (string, result)
179 value = strtoimax (string, &ep, 10);
180 if (errno || ep == string)
181 return 0; /* errno is set on overflow or underflow */
183 /* Skip any trailing whitespace, since strtoimax does not. */
184 while (whitespace (*ep))
187 /* If *string is not '\0' but *ep is '\0' on return, the entire string
189 if (*string && *ep == '\0')
193 /* The SunOS4 implementation of strtol() will happily ignore
194 overflow conditions, so this cannot do overflow correctly
202 /* Return 1 if this token is a legal shell `identifier'; that is, it consists
203 solely of letters, digits, and underscores, and does not begin with a
206 legal_identifier (name)
212 if (!name || !(c = *name) || (legal_variable_starter (c) == 0))
215 for (s = name + 1; (c = *s) != 0; s++)
217 if (legal_variable_char (c) == 0)
223 /* Make sure that WORD is a valid shell identifier, i.e.
224 does not contain a dollar sign, nor is quoted in any way. Nor
225 does it consist of all digits. If CHECK_WORD is non-zero,
226 the word is checked to ensure that it consists of only letters,
227 digits, and underscores. */
229 check_identifier (word, check_word)
233 if ((word->flags & (W_HASDOLLAR|W_QUOTED)) || all_digits (word->word))
235 internal_error (_("`%s': not a valid identifier"), word->word);
238 else if (check_word && legal_identifier (word->word) == 0)
240 internal_error (_("`%s': not a valid identifier"), word->word);
247 /* Return 1 if STRING comprises a valid alias name. The shell accepts
248 essentially all characters except those which must be quoted to the
249 parser (which disqualifies them from alias expansion anyway) and `/'. */
251 legal_alias_name (string, flags)
257 for (s = string; *s; s++)
258 if (shellbreak (*s) || shellxquote (*s) || shellexp (*s) || (*s == '/'))
263 /* Returns non-zero if STRING is an assignment statement. The returned value
264 is the index of the `=' sign. */
266 assignment (string, flags)
270 register unsigned char c;
271 register int newi, indx;
273 c = string[indx = 0];
275 #if defined (ARRAY_VARS)
276 if ((legal_variable_starter (c) == 0) && (flags == 0 || c != '[')) /* ] */
278 if (legal_variable_starter (c) == 0)
282 while (c = string[indx])
284 /* The following is safe. Note that '=' at the start of a word
285 is not an assignment statement. */
289 #if defined (ARRAY_VARS)
292 newi = skipsubscript (string, indx, 0);
293 if (string[newi++] != ']')
295 if (string[newi] == '+' && string[newi+1] == '=')
297 return ((string[newi] == '=') ? newi : 0);
299 #endif /* ARRAY_VARS */
302 if (c == '+' && string[indx+1] == '=')
305 /* Variable names in assignment statements may contain only letters,
307 if (legal_variable_char (c) == 0)
315 /* **************************************************************** */
317 /* Functions to manage files and file descriptors */
319 /* **************************************************************** */
321 /* A function to unset no-delay mode on a file descriptor. Used in shell.c
322 to unset it on the fd passed as stdin. Should be called on stdin if
323 readline gets an EAGAIN or EWOULDBLOCK when trying to read input. */
325 #if !defined (O_NDELAY)
326 # if defined (FNDELAY)
327 # define O_NDELAY FNDELAY
329 #endif /* O_NDELAY */
331 /* Make sure no-delay mode is not set on file descriptor FD. */
333 sh_unset_nodelay_mode (fd)
338 if ((flags = fcntl (fd, F_GETFL, 0)) < 0)
343 /* This is defined to O_NDELAY in filecntl.h if O_NONBLOCK is not present
344 and O_NDELAY is defined. */
346 bflags |= O_NONBLOCK;
356 return (fcntl (fd, F_SETFL, flags));
362 /* Return 1 if file descriptor FD is valid; 0 otherwise. */
367 return (fcntl (fd, F_GETFD, 0) >= 0);
375 if (lseek ((fd), 0L, SEEK_CUR) < 0)
376 return (errno == ESPIPE);
380 /* There is a bug in the NeXT 2.1 rlogind that causes opens
381 of /dev/tty to fail. */
383 #if defined (__BEOS__)
384 /* On BeOS, opening in non-blocking mode exposes a bug in BeOS, so turn it
385 into a no-op. This should probably go away in the future. */
387 # define O_NONBLOCK 0
388 #endif /* __BEOS__ */
396 tty_fd = open ("/dev/tty", O_RDWR|O_NONBLOCK);
400 tty = (char *)ttyname (fileno (stdin));
403 tty_fd = open (tty, O_RDWR|O_NONBLOCK);
409 /* Return 1 if PATH1 and PATH2 are the same file. This is kind of
410 expensive. If non-NULL STP1 and STP2 point to stat structures
411 corresponding to PATH1 and PATH2, respectively. */
413 same_file (path1, path2, stp1, stp2)
415 struct stat *stp1, *stp2;
417 struct stat st1, st2;
421 if (stat (path1, &st1) != 0)
428 if (stat (path2, &st2) != 0)
433 return ((stp1->st_dev == stp2->st_dev) && (stp1->st_ino == stp2->st_ino));
436 /* Move FD to a number close to the maximum number of file descriptors
437 allowed in the shell process, to avoid the user stepping on it with
438 redirection and causing us extra work. If CHECK_NEW is non-zero,
439 we check whether or not the file descriptors are in use before
440 duplicating FD onto them. MAXFD says where to start checking the
441 file descriptors. If it's less than 20, we get the maximum value
442 available from getdtablesize(2). */
444 move_to_high_fd (fd, check_new, maxfd)
445 int fd, check_new, maxfd;
447 int script_fd, nfds, ignore;
451 nfds = getdtablesize ();
454 if (nfds > HIGH_FD_MAX)
455 nfds = HIGH_FD_MAX; /* reasonable maximum */
460 for (nfds--; check_new && nfds > 3; nfds--)
461 if (fcntl (nfds, F_GETFD, &ignore) == -1)
464 if (nfds > 3 && fd != nfds && (script_fd = dup2 (fd, nfds)) != -1)
466 if (check_new == 0 || fd != fileno (stderr)) /* don't close stderr */
471 /* OK, we didn't find one less than our artificial maximum; return the
472 original file descriptor. */
476 /* Return non-zero if the characters from SAMPLE are not all valid
477 characters to be found in the first line of a shell script. We
478 check up to the first newline, or SAMPLE_LEN, whichever comes first.
479 All of the characters must be printable or whitespace. */
482 check_binary_file (sample, sample_len)
489 for (i = 0; i < sample_len; i++)
501 /* **************************************************************** */
503 /* Functions to manipulate pipes */
505 /* **************************************************************** */
513 if ((r = pipe (pv)) < 0)
516 pv[0] = move_to_high_fd (pv[0], 1, 64);
517 pv[1] = move_to_high_fd (pv[1], 1, 64);
536 /* **************************************************************** */
538 /* Functions to inspect pathnames */
540 /* **************************************************************** */
548 return (stat (fn, &sb) == 0);
557 return ((stat (fn, &sb) == 0) && S_ISDIR (sb.st_mode));
564 return (file_isdir (fn) && sh_eaccess (fn, W_OK) == 0);
567 /* Return 1 if STRING is "." or "..", optionally followed by a directory
570 path_dot_or_dotdot (string)
573 if (string == 0 || *string == '\0' || *string != '.')
576 /* string[0] == '.' */
577 if (PATHSEP(string[1]) || (string[1] == '.' && PATHSEP(string[2])))
583 /* Return 1 if STRING contains an absolute pathname, else 0. Used by `cd'
584 to decide whether or not to look up a directory name in $CDPATH. */
586 absolute_pathname (string)
589 if (string == 0 || *string == '\0')
595 if (string[0] == '.' && PATHSEP(string[1])) /* . and ./ */
598 if (string[0] == '.' && string[1] == '.' && PATHSEP(string[2])) /* .. and ../ */
604 /* Return 1 if STRING is an absolute program name; it is absolute if it
605 contains any slashes. This is used to decide whether or not to look
608 absolute_program (string)
611 return ((char *)mbschr (string, '/') != (char *)NULL);
614 /* **************************************************************** */
616 /* Functions to manipulate pathnames */
618 /* **************************************************************** */
620 /* Turn STRING (a pathname) into an absolute pathname, assuming that
621 DOT_PATH contains the symbolic location of `.'. This always
622 returns a new string, even if STRING was an absolute pathname to
625 make_absolute (string, dot_path)
626 char *string, *dot_path;
630 if (dot_path == 0 || ABSPATH(string))
633 char pathbuf[PATH_MAX + 1];
635 cygwin_conv_to_full_posix_path (string, pathbuf);
636 result = savestring (pathbuf);
639 result = savestring (string);
642 result = sh_makepath (dot_path, string, 0);
647 /* Return the `basename' of the pathname in STRING (the stuff after the
648 last '/'). If STRING is `/', just return it. */
650 base_pathname (string)
656 if (absolute_pathname (string) == 0)
660 if (string[0] == '/' && string[1] == 0)
663 p = (char *)strrchr (string, '/');
664 return (p ? ++p : string);
667 /* Return the full pathname of FILE. Easy. Filenames that begin
668 with a '/' are returned as themselves. Other filenames have
669 the current working directory prepended. A new string is
670 returned in either case. */
677 file = (*file == '~') ? bash_tilde_expand (file, 0) : savestring (file);
682 ret = sh_makepath ((char *)NULL, file, (MP_DOCWD|MP_RMDOT));
688 /* A slightly related function. Get the prettiest name of this
689 directory possible. */
690 static char tdir[PATH_MAX];
692 /* Return a pretty pathname. If the first part of the pathname is
693 the same as $HOME, then replace that with `~'. */
695 polite_directory_format (name)
701 home = get_string_value ("HOME");
702 l = home ? strlen (home) : 0;
703 if (l > 1 && strncmp (home, name, l) == 0 && (!name[l] || name[l] == '/'))
705 strncpy (tdir + 1, name + l, sizeof(tdir) - 2);
707 tdir[sizeof(tdir) - 1] = '\0';
714 /* Trim NAME. If NAME begins with `~/', skip over tilde prefix. Trim to
715 keep any tilde prefix and PROMPT_DIRTRIM trailing directory components
716 and replace the intervening characters with `...' */
718 trim_pathname (name, maxlen)
724 char *nbeg, *nend, *ntail, *v;
726 if (name == 0 || (nlen = strlen (name)) == 0)
730 v = get_string_value ("PROMPT_DIRTRIM");
731 if (v == 0 || *v == 0)
733 if (legal_number (v, &nskip) == 0 || nskip <= 0)
736 /* Skip over tilde prefix */
739 for (nbeg = name; *nbeg; nbeg++)
748 for (ndirs = 0, ntail = nbeg; *ntail; ntail++)
754 for (ntail = (*nend == '/') ? nend : nend - 1; ntail > nbeg; ntail--)
764 /* Now we want to return name[0..nbeg]+"..."+ntail, modifying name in place */
774 memmove (nbeg, ntail, nlen);
780 /* Given a string containing units of information separated by colons,
781 return the next one pointed to by (P_INDEX), or NULL if there are no more.
782 Advance (P_INDEX) to the character after the colon. */
784 extract_colon_unit (string, p_index)
794 len = strlen (string);
796 return ((char *)NULL);
800 /* Each call to this routine leaves the index pointing at a colon if
801 there is more to the path. If I is > 0, then increment past the
802 `:'. If I is 0, then the path has a leading colon. Trailing colons
803 are handled OK by the `else' part of the if statement; an empty
804 string is returned in that case. */
805 if (i && string[i] == ':')
808 for (start = i; string[i] && string[i] != ':'; i++)
817 /* Return "" in the case of a trailing `:'. */
818 value = (char *)xmalloc (1);
822 value = substring (string, start, i);
827 /* **************************************************************** */
829 /* Tilde Initialization and Expansion */
831 /* **************************************************************** */
833 #if defined (PUSHD_AND_POPD)
834 extern char *get_dirstack_from_string __P((char *));
837 static char **bash_tilde_prefixes;
838 static char **bash_tilde_prefixes2;
839 static char **bash_tilde_suffixes;
840 static char **bash_tilde_suffixes2;
842 /* If tilde_expand hasn't been able to expand the text, perhaps it
843 is a special shell expansion. This function is installed as the
844 tilde_expansion_preexpansion_hook. It knows how to expand ~- and ~+.
845 If PUSHD_AND_POPD is defined, ~[+-]N expands to directories from the
848 bash_special_tilde_expansions (text)
853 result = (char *)NULL;
855 if (text[0] == '+' && text[1] == '\0')
856 result = get_string_value ("PWD");
857 else if (text[0] == '-' && text[1] == '\0')
858 result = get_string_value ("OLDPWD");
859 #if defined (PUSHD_AND_POPD)
860 else if (DIGIT (*text) || ((*text == '+' || *text == '-') && DIGIT (text[1])))
861 result = get_dirstack_from_string (text);
864 return (result ? savestring (result) : (char *)NULL);
867 /* Initialize the tilde expander. In Bash, we handle `~-' and `~+', as
868 well as handling special tilde prefixes; `:~" and `=~' are indications
869 that we should do tilde expansion. */
873 static int times_called = 0;
875 /* Tell the tilde expander that we want a crack first. */
876 tilde_expansion_preexpansion_hook = bash_special_tilde_expansions;
878 /* Tell the tilde expander about special strings which start a tilde
879 expansion, and the special strings that end one. Only do this once.
880 tilde_initialize () is called from within bashline_reinitialize (). */
881 if (times_called++ == 0)
883 bash_tilde_prefixes = strvec_create (3);
884 bash_tilde_prefixes[0] = "=~";
885 bash_tilde_prefixes[1] = ":~";
886 bash_tilde_prefixes[2] = (char *)NULL;
888 bash_tilde_prefixes2 = strvec_create (2);
889 bash_tilde_prefixes2[0] = ":~";
890 bash_tilde_prefixes2[1] = (char *)NULL;
892 tilde_additional_prefixes = bash_tilde_prefixes;
894 bash_tilde_suffixes = strvec_create (3);
895 bash_tilde_suffixes[0] = ":";
896 bash_tilde_suffixes[1] = "=~"; /* XXX - ?? */
897 bash_tilde_suffixes[2] = (char *)NULL;
899 tilde_additional_suffixes = bash_tilde_suffixes;
901 bash_tilde_suffixes2 = strvec_create (2);
902 bash_tilde_suffixes2[0] = ":";
903 bash_tilde_suffixes2[1] = (char *)NULL;
907 /* POSIX.2, 3.6.1: A tilde-prefix consists of an unquoted tilde character
908 at the beginning of the word, followed by all of the characters preceding
909 the first unquoted slash in the word, or all the characters in the word
910 if there is no slash...If none of the characters in the tilde-prefix are
911 quoted, the characters in the tilde-prefix following the tilde shell be
912 treated as a possible login name. */
914 #define TILDE_END(c) ((c) == '\0' || (c) == '/' || (c) == ':')
917 unquoted_tilde_word (s)
922 for (r = s; TILDE_END(*r) == 0; r++)
935 /* Find the end of the tilde-prefix starting at S, and return the tilde
936 prefix in newly-allocated memory. Return the length of the string in
937 *LENP. FLAGS tells whether or not we're in an assignment context --
938 if so, `:' delimits the end of the tilde prefix as well. */
940 bash_tilde_find_word (s, flags, lenp)
948 for (r = s; *r && *r != '/'; r++)
950 /* Short-circuit immediately if we see a quote character. Even though
951 POSIX says that `the first unquoted slash' (or `:') terminates the
952 tilde-prefix, in practice, any quoted portion of the tilde prefix
953 will cause it to not be expanded. */
954 if (*r == '\\' || *r == '\'' || *r == '"')
956 ret = savestring (s);
961 else if (flags && *r == ':')
965 ret = xmalloc (l + 1);
973 /* Tilde-expand S by running it through the tilde expansion library.
974 ASSIGN_P is 1 if this is a variable assignment, so the alternate
975 tilde prefixes should be enabled (`=~' and `:~', see above). If
976 ASSIGN_P is 2, we are expanding the rhs of an assignment statement,
977 so `=~' is not valid. */
979 bash_tilde_expand (s, assign_p)
983 int old_immed, old_term, r;
986 old_immed = interrupt_immediately;
987 old_term = terminate_immediately;
988 /* We want to be able to interrupt tilde expansion. Ordinarily, we can just
989 jump to top_level, but we don't want to run any trap commands in a signal
990 handler context. We might be able to get away with just checking for
991 things like SIGINT and SIGQUIT. */
992 if (any_signals_trapped () < 0)
993 interrupt_immediately = 1;
994 terminate_immediately = 1;
996 tilde_additional_prefixes = assign_p == 0 ? (char **)0
997 : (assign_p == 2 ? bash_tilde_prefixes2 : bash_tilde_prefixes);
999 tilde_additional_suffixes = bash_tilde_suffixes2;
1001 r = (*s == '~') ? unquoted_tilde_word (s) : 1;
1002 ret = r ? tilde_expand (s) : savestring (s);
1004 interrupt_immediately = old_immed;
1005 terminate_immediately = old_term;
1012 /* **************************************************************** */
1014 /* Functions to manipulate and search the group list */
1016 /* **************************************************************** */
1018 static int ngroups, maxgroups;
1020 /* The set of groups that this user is a member of. */
1021 static GETGROUPS_T *group_array = (GETGROUPS_T *)NULL;
1023 #if !defined (NOGROUP)
1024 # define NOGROUP (gid_t) -1
1028 initialize_group_array ()
1033 maxgroups = getmaxgroups ();
1036 group_array = (GETGROUPS_T *)xrealloc (group_array, maxgroups * sizeof (GETGROUPS_T));
1038 #if defined (HAVE_GETGROUPS)
1039 ngroups = getgroups (maxgroups, group_array);
1042 /* If getgroups returns nothing, or the OS does not support getgroups(),
1043 make sure the groups array includes at least the current gid. */
1046 group_array[0] = current_user.gid;
1050 /* If the primary group is not in the groups array, add it as group_array[0]
1051 and shuffle everything else up 1, if there's room. */
1052 for (i = 0; i < ngroups; i++)
1053 if (current_user.gid == (gid_t)group_array[i])
1055 if (i == ngroups && ngroups < maxgroups)
1057 for (i = ngroups; i > 0; i--)
1058 group_array[i] = group_array[i - 1];
1059 group_array[0] = current_user.gid;
1063 /* If the primary group is not group_array[0], swap group_array[0] and
1064 whatever the current group is. The vast majority of systems should
1065 not need this; a notable exception is Linux. */
1066 if (group_array[0] != current_user.gid)
1068 for (i = 0; i < ngroups; i++)
1069 if (group_array[i] == current_user.gid)
1073 group_array[i] = group_array[0];
1074 group_array[0] = current_user.gid;
1079 /* Return non-zero if GID is one that we have in our groups list. */
1081 #if defined (__STDC__) || defined ( _MINIX)
1082 group_member (gid_t gid)
1086 #endif /* !__STDC__ && !_MINIX */
1088 #if defined (HAVE_GETGROUPS)
1092 /* Short-circuit if possible, maybe saving a call to getgroups(). */
1093 if (gid == current_user.gid || gid == current_user.egid)
1096 #if defined (HAVE_GETGROUPS)
1098 initialize_group_array ();
1100 /* In case of error, the user loses. */
1104 /* Search through the list looking for GID. */
1105 for (i = 0; i < ngroups; i++)
1106 if (gid == (gid_t)group_array[i])
1114 get_group_list (ngp)
1117 static char **group_vector = (char **)NULL;
1124 return group_vector;
1128 initialize_group_array ();
1134 return (char **)NULL;
1137 group_vector = strvec_create (ngroups);
1138 for (i = 0; i < ngroups; i++)
1139 group_vector[i] = itos (group_array[i]);
1143 return group_vector;
1147 get_group_array (ngp)
1151 static int *group_iarray = (int *)NULL;
1157 return (group_iarray);
1161 initialize_group_array ();
1170 group_iarray = (int *)xmalloc (ngroups * sizeof (int));
1171 for (i = 0; i < ngroups; i++)
1172 group_iarray[i] = (int)group_array[i];
1176 return group_iarray;