Linux test file executable

Unix / Linux — Shell File Test Operators Example

We have a few operators that can be used to test various properties associated with a Unix file.

Assume a variable file holds an existing file name «test» the size of which is 100 bytes and has read, write and execute permission on −

Operator	Description	Example
-b file	Checks if file is a block special file; if yes, then the condition becomes true.	[ -b $file ] is false.
-c file	Checks if file is a character special file; if yes, then the condition becomes true.	[ -c $file ] is false.
-d file	Checks if file is a directory; if yes, then the condition becomes true.	[ -d $file ] is not true.
-f file	Checks if file is an ordinary file as opposed to a directory or special file; if yes, then the condition becomes true.	[ -f $file ] is true.
-g file	Checks if file has its set group ID (SGID) bit set; if yes, then the condition becomes true.	[ -g $file ] is false.
-k file	Checks if file has its sticky bit set; if yes, then the condition becomes true.	[ -k $file ] is false.
-p file	Checks if file is a named pipe; if yes, then the condition becomes true.	[ -p $file ] is false.
-t file	Checks if file descriptor is open and associated with a terminal; if yes, then the condition becomes true.	[ -t $file ] is false.
-u file	Checks if file has its Set User ID (SUID) bit set; if yes, then the condition becomes true.	[ -u $file ] is false.
-r file	Checks if file is readable; if yes, then the condition becomes true.	[ -r $file ] is true.
-w file	Checks if file is writable; if yes, then the condition becomes true.	[ -w $file ] is true.
-x file	Checks if file is executable; if yes, then the condition becomes true.	[ -x $file ] is true.
-s file	Checks if file has size greater than 0; if yes, then condition becomes true.	[ -s $file ] is true.
-e file	Checks if file exists; is true even if file is a directory but exists.	[ -e $file ] is true.

Example

The following example uses all the file test operators −

Assume a variable file holds an existing file name «/var/www/tutorialspoint/unix/test.sh» the size of which is 100 bytes and has read, write and execute permission −

The above script will produce the following result −

The following points need to be considered while using file test operators −

There must be spaces between the operators and the expressions. For example, 2+2 is not correct; it should be written as 2 + 2.

if. then. else. fi statement is a decision-making statement which has been explained in the next chapter.

Источник

Как проверить, является ли файл исполняемым, с помощью команды file в Bash?

У меня есть задание, в котором я должен использовать команду file, чтобы проверить, является ли файл исполняемым типом или нет.

Формулировка, использованная в задании, следующая:

Команду file следует использовать для общего определения типа файла аргумента и, в частности, является ли файл исполняемым типом или нет. Выходные данные команды файла будут включать специальное ключевое слово «исполняемый», если файл является исполняемым типом.

Далее в вопросе говорится:

1. Используйте файл и найдите в выходных данных ключевое слово «исполняемый», чтобы определить, является ли файл исполняемым типом или нет.

Мне пока не удалось найти какую-либо документацию, объясняющую, как это сделать. Когда я тестирую это на bash-скрипте в CentOS8, он возвращает это как результат:

Edit1 / found_the_answer_edit: Я попытался использовать идею ti7 об использовании тестового сценария, и он получил тот же результат, что и они. Это заставило меня задуматься. Сценарии для моих заданий должны быть отформатированы. В частности, чтобы получить признание наших скриптов, мы должны иметь:

2 ответа

Ваш сценарий validate.sh , вероятно, не исполняемый, как это определяет file ! Вероятно, это потому, что на нем неправильный заголовок

Как только это будет решено, вы можете проверить ключевое слово executable в ответе, возможно, с помощью grep

Если вас не заставляют использовать file , использование аргумента test -x может быть намного лучше, чем предлагается здесь, поскольку file не проверяет разрешения , а указывает, что формат файла является исполняемым

Обратите внимание, что команда тестовой команды на самом деле [ или [[ с небольшими отличиями

Вы можете проверить права доступа к нему с помощью ls , в котором перечислены файлы в каталоге и, при необходимости, их свойства.

Вы можете сделать свой скрипт исполняемым с помощью chmod (тривиально, chmod +x )

Не уверен, действительно ли это bash, работающий в Windows, и, возможно, WSL. Если это так, файл фактически вернет, что данный исполняемый файл Windows является исполняемым.

Имея это в виду, вы можете перейти к grep и протестировать результат, т.е.

Источник

How to make a file executable? [duplicate]

How can I make my file so that I can double click on it, and it runs. It is a .sh script, but I also have files that say:

in the description of what they are.

I can’t run any of these from terminal, or by double clicking.

If possible, I would like a way using either the GUI or a Terminal, but not a combination of the two.

Here is a screenshot of what I see when I right click then go on properties. The file first:

And the shell script here:

NB: I accept that this is a duplicate (I was looking for it, and couldn’t find it, so asked + answered it, hoping that I would find it) however, I don’t think the question about .desktop files is a duplicate.

1 Answer 1

There are two ways of making a file executable:

GUI Method:

Go to the permissions tab, then tick the box Execute: [✓] Allow executing file as program.

Command line method:

Note that chmod does also have some more advanced options. It accepts three groups of options, represented as — — — . The first set of — is User. The second is Group and the last is Other (everyone else).

r stands for Read, w for Write and x for eXecute.

To allow everyone to read it, but only Group to execute and User to read and write it would be -rw- rx- r— . This would be added to the command as:

chmod also can do this in numbers. It is based on binary.

So there are these numbers:

Execute by user is 100 . Execute by group is 010 . Execute by other is 001

Write by user is 200 . Write by group is 020 . Write by other is 002 .

Read by user is 400 . Read by group is 040 . Read by other is 004 .

Then you add these together to get the desired combination.

So to allow everyone to read it, but only Group to execute and User to write it would be 400 + 040 + 004 and 010 and 200

That adds up to 600 + 050 + 004 = 654 .

You could then run the command.

to set it. So to set all permissions you can run:

Finally, you can do:

To take all permissions away from everyone.

To add read and write for the user, without affecting any other permissions (e.g. Execute permissions).

This website has a very useful little tool, whereby you can tick the options you want and it gives you the command:

However, not all the possible combinations are sensible to use; the main ones that are used are the following:

755 — Owner has all, and Group and Other can read and execute

700 — Owner has all

644 — Owner can read and write, and Group and Other can read

600 — Owner can read and write

And, if you’re using non-trivial user groups:

775 — Owner can read and write, and Group and Other can read

770 — Owner and Group have all, and Other can read and execute

750 — Owner has all, and Group can read and execute

664 — Owner and Group can read and write, and Other can just read

660 — Owner and Group can read and write

640 — Owner can read and write, and Group can read

777 and 666 are rarely used, except in /tmp .

Thanks Ilmari Karonen for pointing out the ones in common usage!

Источник

Check if a file is executable

I am wondering what’s the easiest way to check if a program is executable with bash, without executing it ? It should at least check whether the file has execute rights, and is of the same architecture (for example, not a windows executable or another unsupported architecture, not 64 bits if the system is 32 bits, . ) as the current system.

7 Answers 7

Take a look at the various test operators (this is for the test command itself, but the built-in BASH and TCSH tests are more or less the same).

You’ll notice that -x FILE says FILE exists and execute (or search) permission is granted.

BASH, Bourne, Ksh, Zsh Script

TCSH or CSH Script:

To determine the type of file it is, try the file command. You can parse the output to see exactly what type of file it is. Word ‘o Warning: Sometimes file will return more than one line. Here’s what happens on my Mac:

The file command returns different output depending upon the OS. However, the word executable will be in executable programs, and usually the architecture will appear too.

Compare the above to what I get on my Linux box:

And a Solaris box:

In all three, you’ll see the word executable and the architecture ( x86-64 , i386 , or SPARC with 32-bit ).

Addendum

Thank you very much, that seems the way to go. Before I mark this as my answer, can you please guide me as to what kind of script shell check I would have to perform (ie, what kind of parsing) on ‘file’ in order to check whether I can execute a program ? If such a test is too difficult to make on a general basis, I would at least like to check whether it’s a linux executable or osX (Mach-O)

Off the top of my head, you could do something like this in BASH:

Basically, I’m running the test, then if that is successful, I do a grep on the output of the file command. The grep -q means don’t print any output, but use the exit code of grep to see if I found the string. If your system doesn’t take grep -q , you can try grep «regex» > /dev/null 2>&1 .

Again, the output of the file command may vary from system to system, so you’ll have to verify that these will work on your system. Also, I’m checking the executable bit. If a file is a binary executable, but the executable bit isn’t on, I’ll say it’s not executable. This may not be what you want.

Источник

Search for executable files using find command

What type of parameter/flag can I use with the Unix find command so that I search executables?

10 Answers 10

On GNU versions of find you can use -executable :

For BSD versions of find, you can use -perm with + and an octal mask:

In this context «+» means «any of these bits are set» and 111 is the execute bits.

Note that this is not identical to the -executable predicate in GNU find. In particular, -executable tests that the file can be executed by the current user, while -perm +111 just tests if any execute permissions are set.

Older versions of GNU find also support the -perm +111 syntax, but as of 4.5.12 this syntax is no longer supported. Instead, you can use -perm /111 to get this behavior.

Tip of the hat to @gniourf_gniourf for clearing up a fundamental misconception.

This answer attempts to provide an overview of the existing answers and to discuss their subtleties and relative merits as well as to provide background information, especially with respect to portability.

Finding files that are executable can refer to two distinct use cases:

• user-centric: find files that are executable by the current user.
• file-centric: find files that have (one or more) executable permission bits set.

Note that in either scenario it may make sense to use find -L . instead of just find . in order to also find symlinks to executables.

Note that the simplest file-centric case — looking for executables with the executable permissions bit set for ALL three security principals (user, group, other) — will typically, but not necessarily yield the same results as the user-centric scenario — and it’s important to understand the difference.

User-centric ( -executable )

The accepted answer commendably recommends -executable , IF GNU find is available.

• GNU find comes with most Linux distros
  • By contrast, BSD-based platforms, including macOS, come with BSD find, which is less powerful.
• As the scenario demands, -executable matches only files the current user can execute (there are edge cases. [1] ).

The BSD find alternative offered by the accepted answer ( -perm +111 ) answers a different, file-centric question (as the answer itself states).

Using just -perm to answer the user-centric question is impossible, because what is needed is to relate the file’s user and group identity to the current user’s, whereas -perm can only test the file’s permissions.
Using only POSIX find features, the question cannot be answered without involving external utilities.

Thus, the best -perm can do (by itself) is an approximation of -executable . Perhaps a closer approximation than -perm +111 is -perm -111 , so as to find files that have the executable bit set for ALL security principals (user, group, other) — this strikes me as the typical real-world scenario. As a bonus, it also happens to be POSIX-compliant (use find -L to include symlinks, see farther below for an explanation):

gniourf_gniourf’s answer provides a true, portable equivalent of -executable , using -exec test -x <> \; , albeit at the expense of performance.

Combining -exec test -x <> \; with -perm +111 (i.e., files with at least one executable bit set) may help performance in that exec needn’t be invoked for every file (the following uses the POSIX-compliant equivalent of BSD find -perm +111 / GNU find -perm /111 ; see farther below for an explanation):

File-centric ( -perm )

• To answer file-centric questions, it issufficient to use the POSIX-compliant -perm primary (known as a test in GNU find terminology).
  • -perm allows you to test for any file permissions, not just executability.
  • Permissions are specified as either octal or symbolic modes. Octal modes are octal numbers (e.g., 111 ), whereas symbolic modes are strings (e.g., a=x ).
  • Symbolic modes identify the security principals as u (user), g (group) and o (other), or a to refer to all three. Permissions are expressed as x for executable, for instance, and assigned to principals using operators = , + and — ; for a full discussion, including of octal modes, see the POSIX spec for the chmod utility.
  • In the context of find :
    • Prefixing a mode with — (e.g., -ug=x ) means: match files that have all the permissions specified (but matching files may have additional permissions).
    • Having NO prefix (e.g. 755 ) means: match files that have this full, exact set of permissions.
    • Caveat: Both GNU find and BSD find implement an additional, nonstandard prefix with are-ANY-of-the-specified-permission-bits-set logic, but do so with incompatible syntax:
      • BSD find: +
      • GNU find: / [2]
    • Therefore, avoid these extensions, if your code must be portable.
• The examples below demonstrate portable answers to various file-centric questions.

File-centric command examples

• The following examples are POSIX-compliant, meaning they should work in any POSIX-compatible implementation, including GNU find and BSD find; specifically, this requires:
  • NOT using nonstandard mode prefixes + or / .
  • Using the POSIX forms of the logical-operator primaries:
    • ! for NOT (GNU find and BSD find also allow -not ); note that \! is used in the examples so as to protect ! from shell history expansions
    • -a for AND (GNU find and BSD find also allow -and )
    • -o for OR (GNU find and BSD find also allow -or )
• The examples use symbolic modes, because they’re easier to read and remember.
  • With mode prefix — , the = and + operators can be used interchangeably (e.g., -u=x is equivalent to -u+x — unless you apply -x later, but there’s no point in doing that).
  • Use , to join partial modes; AND logic is implied; e.g., -u=x,g=x means that both the user and the group executable bit must be set.
  • Modes cannot themselves express negative matching in the sense of «match only if this bit is NOT set»; you must use a separate -perm expression with the NOT primary, ! .
• Note that find’s primaries (such as -print , or -perm ; also known as actions and tests in GNU find) are implicitly joined with -a (logical AND), and that -o and possibly parentheses (escaped as \( and \) for the shell) are needed to implement OR logic.
• find -L . instead of just find . is used in order to also match symlinks to executables
  • -L instructs find to evaluate the targets of symlinks instead of the symlinks themselves; therefore, without -L , -type f would ignore symlinks altogether.

[1] Description of -executable from man find as of GNU find 4.4.2:

Matches files which are executable and directories which are searchable (in a file name resolution sense). This takes into account access control lists and other permissions artefacts which the -perm test ignores. This test makes use of the access(2) system call, and so can be fooled by NFS servers which do UID mapping (or root-squashing), since many systems implement access(2) in the client’s kernel and so cannot make use of the UID mapping information held on the server. Because this test is based only on the result of the access(2) system call, there is no guarantee that a file for which this test succeeds can actually be executed.

[2] GNU find versions older than 4.5.12 also allowed prefix + , but this was first deprecated and eventually removed, because combining + with symbolic modes yields likely yields unexpected results due to being interpreted as an exact permissions mask. If you (a) run on a version before 4.5.12 and (b) restrict yourself to octal modes only, you could get away with using + with both GNU find and BSD find, but it’s not a good idea.

Источник