]>
git.ipfire.org Git - thirdparty/bash.git/blob - findcmd.c
1 /* findcmd.c -- Functions to search for commands by name. */
3 /* Copyright (C) 1997-2023 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/>.
24 #include "chartypes.h"
25 #include "bashtypes.h"
26 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
27 # include <sys/file.h>
30 #include "posixstat.h"
32 #if defined (HAVE_UNISTD_H)
41 #include "execute_cmd.h"
46 #include "findcmd.h" /* matching prototypes and declarations */
48 #include <glob/strmatch.h>
54 /* Static functions defined and used in this file. */
55 static char *_find_user_command_internal (const char *, int);
56 static char *find_user_command_internal (const char *, int);
57 static char *find_user_command_in_path (const char *, char *, int, int *);
58 static char *find_in_path_element (const char *, char *, int, size_t, struct stat
*, int *);
59 static char *find_absolute_program (const char *, int);
61 static char *get_next_path_element (char *, int *);
63 /* The file name which we would try to execute, except that it isn't
64 possible to execute it. This is the first file that matches the
65 name that we are looking for while we are searching $PATH for a
66 suitable one to execute. If we cannot find a suitable executable
67 file, then we use this one. */
68 static char *file_to_lose_on
;
70 /* Non-zero if we should stat every command found in the hash table to
71 make sure it still exists. */
72 int check_hashed_filenames
= CHECKHASH_DEFAULT
;
74 /* DOT_FOUND_IN_SEARCH becomes non-zero when find_user_command ()
75 encounters a `.' as the directory pathname while scanning the
76 list of possible pathnames; i.e., if `.' comes before the directory
77 containing the file of interest. */
78 int dot_found_in_search
= 0;
80 /* Set up EXECIGNORE; a blacklist of patterns that executable files should not
82 static struct ignorevar execignore
=
92 setup_exec_ignore (const char *varname
)
94 setup_ignore_patterns (&execignore
);
98 exec_name_should_ignore (const char *name
)
102 for (p
= execignore
.ignores
; p
&& p
->val
; p
++)
103 if (strmatch (p
->val
, (char *)name
, FNMATCH_EXTFLAG
|FNM_CASEFOLD
) != FNM_NOMATCH
)
108 /* Return some flags based on information about this file.
109 The EXISTS bit is non-zero if the file is found.
110 The EXECABLE bit is non-zero the file is executable.
111 Zero is returned if the file is not found. */
113 file_status (const char *name
)
118 /* Determine whether this file exists or not. */
119 if (stat (name
, &finfo
) < 0)
122 /* If the file is a directory, then it is not "executable" in the
123 sense of the shell. */
124 if (S_ISDIR (finfo
.st_mode
))
125 return (FS_EXISTS
|FS_DIRECTORY
);
129 #if defined (HAVE_EACCESS)
130 /* Use eaccess(2) if we have it to take things like ACLs and other
131 file access mechanisms into account. eaccess uses the effective
132 user and group IDs, not the real ones. We could use sh_eaccess,
133 but we don't want any special treatment for /dev/fd. */
134 if (exec_name_should_ignore (name
) == 0 && eaccess (name
, X_OK
) == 0)
136 if (eaccess (name
, R_OK
) == 0)
141 /* We have to use access(2) to determine access because AFS does not
142 support Unix file system semantics. This may produce wrong
143 answers for non-AFS files when ruid != euid. I hate AFS. */
144 if (exec_name_should_ignore (name
) == 0 && access (name
, X_OK
) == 0)
146 if (access (name
, R_OK
) == 0)
150 #else /* !HAVE_EACCESS && !AFS */
152 /* Find out if the file is actually executable. By definition, the
153 only other criteria is that the file has an execute bit set that
154 we can use. The same with whether or not a file is readable. */
156 /* Root only requires execute permission for any of owner, group or
157 others to be able to exec a file, and can read any file. */
158 if (current_user
.euid
== (uid_t
)0)
161 if (exec_name_should_ignore (name
) == 0 && (finfo
.st_mode
& S_IXUGO
))
166 /* If we are the owner of the file, the owner bits apply. */
167 if (current_user
.euid
== finfo
.st_uid
)
169 if (exec_name_should_ignore (name
) == 0 && (finfo
.st_mode
& S_IXUSR
))
171 if (finfo
.st_mode
& S_IRUSR
)
175 /* If we are in the owning group, the group permissions apply. */
176 else if (group_member (finfo
.st_gid
))
178 if (exec_name_should_ignore (name
) == 0 && (finfo
.st_mode
& S_IXGRP
))
180 if (finfo
.st_mode
& S_IRGRP
)
184 /* Else we check whether `others' have permission to execute the file */
187 if (exec_name_should_ignore (name
) == 0 && finfo
.st_mode
& S_IXOTH
)
189 if (finfo
.st_mode
& S_IROTH
)
197 /* Return non-zero if FILE exists and is executable.
198 Note that this function is the definition of what an
199 executable file is; do not change this unless YOU know
200 what an executable file is. */
202 executable_file (const char *file
)
206 s
= file_status (file
);
208 if (s
& FS_DIRECTORY
)
209 errno
= EISDIR
; /* let's see if we can improve error messages */
211 return ((s
& FS_EXECABLE
) && ((s
& FS_DIRECTORY
) == 0));
215 is_directory (const char *file
)
217 return (file_status (file
) & FS_DIRECTORY
);
221 executable_or_directory (const char *file
)
225 s
= file_status (file
);
226 return ((s
& FS_EXECABLE
) || (s
& FS_DIRECTORY
));
229 /* Locate the executable file referenced by NAME, searching along
230 the contents of the shell PATH variable. Return a new string
231 which is the full pathname to the file, or NULL if the file
232 couldn't be found. If a file is found that isn't executable,
233 and that is the only match, then return that. */
235 find_user_command (const char *name
)
237 return (find_user_command_internal (name
, FS_EXEC_PREFERRED
|FS_NODIRS
));
240 /* Locate the file referenced by NAME, searching along the contents
241 of the shell PATH variable. Return a new string which is the full
242 pathname to the file, or NULL if the file couldn't be found. This
243 returns the first readable file found; designed to be used to look
244 for shell scripts or files to source. */
246 find_path_file (const char *name
)
248 return (find_user_command_internal (name
, FS_READABLE
));
251 /* Get $PATH and normalize it. USE_TEMPENV, if non-zero, says to look in the
252 temporary environment first. Normalizing means converting PATH= into ".". */
254 path_value (const char *pathvar
, int use_tempenv
)
259 var
= use_tempenv
? find_variable_tempenv (pathvar
) : find_variable (pathvar
);
260 path
= var
? value_cell (var
) : (char *)NULL
;
262 if (path
== 0 || *path
)
264 else /* *path == '\0' */
269 _find_user_command_internal (const char *name
, int flags
)
271 char *path_list
, *cmd
;
274 /* Search for the value of PATH in both the temporary environments and
275 in the regular list of variables. */
276 path_list
= path_value ("PATH", 1);
279 return (savestring (name
));
281 cmd
= find_user_command_in_path (name
, path_list
, flags
, (int *)0);
287 find_user_command_internal (const char *name
, int flags
)
292 dotexe
= (char *)xmalloc (strlen (name
) + 5);
293 strcpy (dotexe
, name
);
294 strcat (dotexe
, ".exe");
295 res
= _find_user_command_internal (dotexe
, flags
);
298 res
= _find_user_command_internal (name
, flags
);
301 return (_find_user_command_internal (name
, flags
));
305 /* Return the next element from PATH_LIST, a colon separated list of
306 paths. PATH_INDEX_POINTER is the address of an index into PATH_LIST;
307 the index is modified by this function.
308 Return the next element of PATH_LIST or NULL if there are no more. */
310 get_next_path_element (char *path_list
, int *path_index_pointer
)
314 path
= extract_colon_unit (path_list
, path_index_pointer
);
322 path
= savestring (".");
328 /* Look for PATHNAME in $PATH. Returns either the hashed command
329 corresponding to PATHNAME or the first instance of PATHNAME found
330 in $PATH. If (FLAGS&CMDSRCH_HASH) is non-zero, insert the instance of
331 PATHNAME found in $PATH into the command hash table.
332 If (FLAGS&CMDSRCH_STDPATH) is non-zero, we are running in a `command -p'
333 environment and should use the Posix standard path.
334 Returns a newly-allocated string. */
336 search_for_command (const char *pathname
, int flags
)
338 char *hashed_file
, *command
, *path_list
;
342 hashed_file
= command
= (char *)NULL
;
344 /* If PATH is in the temporary environment for this command, don't use the
345 hash table to search for the full pathname. */
346 path
= find_variable_tempenv ("PATH");
347 temp_path
= path
&& tempvar_p (path
);
349 /* Don't waste time trying to find hashed data for a pathname
350 that is already completely specified or if we're using a command-
351 specific value for PATH. */
352 if (temp_path
== 0 && (flags
& CMDSRCH_STDPATH
) == 0 && absolute_program (pathname
) == 0)
353 hashed_file
= phash_search (pathname
);
355 /* If a command found in the hash table no longer exists, we need to
356 look for it in $PATH. Thank you Posix.2. This forces us to stat
357 every command found in the hash table. */
359 if (hashed_file
&& (posixly_correct
|| check_hashed_filenames
))
361 st
= file_status (hashed_file
);
362 if ((st
& (FS_EXISTS
|FS_EXECABLE
)) != (FS_EXISTS
|FS_EXECABLE
))
364 phash_remove (pathname
);
366 hashed_file
= (char *)NULL
;
371 command
= hashed_file
;
372 else if (absolute_program (pathname
))
373 /* A command containing a slash is not looked up in PATH or saved in
375 command
= savestring (pathname
);
378 if (flags
& CMDSRCH_STDPATH
)
379 path_list
= conf_standard_path ();
380 else if (temp_path
|| path
)
382 path_list
= value_cell (path
);
383 if (path_list
&& *path_list
== '\0')
389 command
= find_user_command_in_path (pathname
, path_list
, FS_EXEC_PREFERRED
|FS_NODIRS
, &st
);
391 if (command
&& hashing_enabled
&& temp_path
== 0 && (flags
& CMDSRCH_HASH
))
393 /* If we found the full pathname the same as the command name, the
394 command probably doesn't exist. Don't put it into the hash
395 table unless it's an executable file in the current directory. */
396 if (STREQ (command
, pathname
))
400 dot_found_in_search
= 1;
401 st
= file_status (pathname
);
403 if (st
& FS_EXECABLE
)
404 phash_insert ((char *)pathname
, command
, dot_found_in_search
, 1);
406 /* If we're in posix mode, don't add files without the execute bit
407 to the hash table. */
408 else if (posixly_correct
|| check_hashed_filenames
)
410 if (st
& FS_EXECABLE
)
411 phash_insert ((char *)pathname
, command
, dot_found_in_search
, 1);
414 phash_insert ((char *)pathname
, command
, dot_found_in_search
, 1);
417 if (flags
& CMDSRCH_STDPATH
)
425 user_command_matches (const char *name
, int flags
, int state
)
430 char *path_list
, *path_element
, *match
;
432 static char **match_list
= NULL
;
433 static size_t match_list_size
= 0;
434 static size_t match_index
= 0;
438 /* Create the list of matches. */
442 match_list
= strvec_create (match_list_size
);
445 /* Clear out the old match list. */
446 for (i
= 0; i
< match_list_size
; i
++)
449 /* We haven't found any files yet. */
452 if (absolute_program (name
))
454 match_list
[0] = find_absolute_program (name
, flags
);
455 match_list
[1] = (char *)NULL
;
456 path_list
= (char *)NULL
;
460 name_len
= strlen (name
);
461 file_to_lose_on
= (char *)NULL
;
462 dot_found_in_search
= 0;
463 if (stat (".", &dotinfo
) < 0)
464 dotinfo
.st_dev
= dotinfo
.st_ino
= 0; /* so same_file won't match */
465 path_list
= path_value ("PATH", 0);
469 while (path_list
&& path_list
[path_index
])
471 path_element
= get_next_path_element (path_list
, &path_index
);
473 if (path_element
== 0)
476 match
= find_in_path_element (name
, path_element
, flags
, name_len
, &dotinfo
, (int *)0);
482 if (match_index
+ 1 == match_list_size
)
484 match_list_size
+= 10;
485 match_list
= strvec_resize (match_list
, (match_list_size
+ 1));
488 match_list
[match_index
++] = match
;
489 match_list
[match_index
] = (char *)NULL
;
490 FREE (file_to_lose_on
);
491 file_to_lose_on
= (char *)NULL
;
494 /* We haven't returned any strings yet. */
498 match
= match_list
[match_index
];
507 find_absolute_program (const char *name
, int flags
)
511 st
= file_status (name
);
513 /* If the file doesn't exist, quit now. */
514 if ((st
& FS_EXISTS
) == 0)
515 return ((char *)NULL
);
517 /* If we only care about whether the file exists or not, return
518 this filename. Otherwise, maybe we care about whether this
519 file is executable. If it is, and that is what we want, return it. */
520 if ((flags
& FS_EXISTS
) || ((flags
& FS_EXEC_ONLY
) && (st
& FS_EXECABLE
)))
521 return (savestring (name
));
527 find_in_path_element (const char *name
, char *path
, int flags
, size_t name_len
, struct stat
*dotinfop
, int *rflagsp
)
530 char *full_path
, *xpath
;
532 xpath
= (posixly_correct
== 0 && *path
== '~') ? bash_tilde_expand (path
, 0) : path
;
534 /* Remember the location of "." in the path, in all its forms
535 (as long as they begin with a `.', e.g. `./.') */
536 /* We could also do this or something similar for all relative pathnames
537 found while searching PATH. */
538 if (dot_found_in_search
== 0 && *xpath
== '.')
539 dot_found_in_search
= same_file (".", xpath
, dotinfop
, (struct stat
*)NULL
);
541 full_path
= sh_makepath (xpath
, name
, 0);
543 status
= file_status (full_path
);
551 if ((status
& FS_EXISTS
) == 0)
554 return ((char *)NULL
);
557 /* The file exists. If the caller simply wants the first file, here it is. */
558 if (flags
& FS_EXISTS
)
561 /* If we have a readable file, and the caller wants a readable file, this
563 if ((flags
& FS_READABLE
) && (status
& FS_READABLE
))
566 /* If the file is executable, then it satisfies the cases of
567 EXEC_ONLY and EXEC_PREFERRED. Return this file unconditionally. */
568 if ((status
& FS_EXECABLE
) && (flags
& (FS_EXEC_ONLY
|FS_EXEC_PREFERRED
)) &&
569 (((flags
& FS_NODIRS
) == 0) || ((status
& FS_DIRECTORY
) == 0)))
571 FREE (file_to_lose_on
);
572 file_to_lose_on
= (char *)NULL
;
576 /* The file is not executable, but it does exist. If we prefer
577 an executable, then remember this one if it is the first one
579 if ((flags
& FS_EXEC_PREFERRED
) && file_to_lose_on
== 0 && exec_name_should_ignore (full_path
) == 0)
580 file_to_lose_on
= savestring (full_path
);
582 /* If we want only executable files, or we don't want directories and
583 this file is a directory, or we want a readable file and this file
584 isn't readable, fail. */
585 if ((flags
& (FS_EXEC_ONLY
|FS_EXEC_PREFERRED
)) ||
586 ((flags
& FS_NODIRS
) && (status
& FS_DIRECTORY
)) ||
587 ((flags
& FS_READABLE
) && (status
& FS_READABLE
) == 0))
590 return ((char *)NULL
);
596 /* This does the dirty work for find_user_command_internal () and
597 user_command_matches ().
598 NAME is the name of the file to search for.
599 PATH_LIST is a colon separated list of directories to search. It is the
600 caller's responsibility to pass a non-empty path if they want an empty
601 path to be treated specially.
602 FLAGS contains bit fields which control the files which are eligible.
604 FS_EXEC_ONLY: The file must be an executable to be found.
605 FS_EXEC_PREFERRED: If we can't find an executable, then the
606 the first file matching NAME will do.
607 FS_EXISTS: The first file found will do.
608 FS_NODIRS: Don't find any directories.
611 find_user_command_in_path (const char *name
, char *path_list
, int flags
, int *rflagsp
)
613 char *full_path
, *path
;
614 int path_index
, rflags
;
618 /* We haven't started looking, so we certainly haven't seen
619 a `.' as the directory path yet. */
620 dot_found_in_search
= 0;
625 if (absolute_program (name
))
627 full_path
= find_absolute_program (name
, flags
);
631 if (path_list
== 0 || *path_list
== '\0')
632 return (savestring (name
)); /* XXX */
634 file_to_lose_on
= (char *)NULL
;
635 name_len
= strlen (name
);
636 if (stat (".", &dotinfo
) < 0)
637 dotinfo
.st_dev
= dotinfo
.st_ino
= 0;
640 while (path_list
[path_index
])
642 /* Allow the user to interrupt out of a lengthy path search. */
645 path
= get_next_path_element (path_list
, &path_index
);
649 /* Side effects: sets dot_found_in_search, possibly sets
651 full_path
= find_in_path_element (name
, path
, flags
, name_len
, &dotinfo
, &rflags
);
654 /* We use the file status flag bits to check whether full_path is a
655 directory, which we reject here. */
656 if (full_path
&& (rflags
& FS_DIRECTORY
))
666 FREE (file_to_lose_on
);
671 /* We didn't find exactly what the user was looking for. Return
672 the contents of FILE_TO_LOSE_ON which is NULL when the search
673 required an executable, or non-NULL if a file was found and the
674 search would accept a non-executable as a last resort. If the
675 caller specified FS_NODIRS, and file_to_lose_on is a directory,
677 if (file_to_lose_on
&& (flags
& FS_NODIRS
) && file_isdir (file_to_lose_on
))
679 free (file_to_lose_on
);
680 file_to_lose_on
= (char *)NULL
;
683 return (file_to_lose_on
);
686 /* External interface to find a command given a $PATH. Separate from
687 find_user_command_in_path to allow future customization. */
689 find_in_path (const char *name
, char *path_list
, int flags
)
691 return (find_user_command_in_path (name
, path_list
, flags
, (int *)0));