programas - ejecutar bash linux

Compruebe si un archivo es ejecutable

Question

Me pregunto cuál es la forma más fácil de verificar si un programa es ejecutable con bash, sin ejecutarlo. Al menos debe verificar si el archivo tiene derechos de ejecución y tiene la misma arquitectura (por ejemplo, no es un ejecutable de Windows u otra arquitectura no compatible, ni 64 bits si el sistema es de 32 bits, ...) como el sistema actual.

Answer 1

Pruebas de archivos, directorios y enlaces simbólicos.

Las soluciones que se dan aquí fallan en los directorios o enlaces simbólicos (o ambos). En Linux, puede probar archivos, directorios y enlaces simbólicos con:

if [[ -f "$file" && -x $(realpath "$file") ]]; then .... fi

En OS X, deberías poder instalar coreutils con homebrew y usar grealpath .

Definiendo una función isexec

Puedes definir una función por conveniencia:

isexec() {
if [[ -f "$1" && -x $(realpath "$1") ]]; then
echo true;
else
echo false;
fi;
}

Entonces puedes probar usando:

if `isexec "$file"`; then ... fi

Answer 2

Eche un vistazo a los distintos operadores de test (esto es para el comando de prueba en sí, pero las pruebas BASH y TCSH incorporadas son más o menos las mismas).

Notarás que -x FILE dice que ARCHIVO existe y se otorga permiso de búsqueda (o búsqueda) .

BASH, Bourne, Ksh, Zsh Script

if [[ -x "$file" ]]
then
echo "File ''$file'' is executable"
else
echo "File ''$file'' is not executable or found"
fi

TCSH o CSH Script:

if ( -x "$file" ) then
echo "File ''$file'' is executable"
else
echo "File ''$file'' is not executable or found"
endif

Para determinar el tipo de archivo, pruebe el comando de file . Puede analizar la salida para ver exactamente qué tipo de archivo es. Word ''o Advertencia : A veces el file devolverá más de una línea. Esto es lo que sucede en mi Mac:

$ file /bin/ls
/bin/ls: Mach-O universal binary with 2 architectures
/bin/ls (for architecture x86_64): Mach-O 64-bit executable x86_64
/bin/ls (for architecture i386): Mach-O executable i386

El comando de file devuelve salida diferente dependiendo del sistema operativo. Sin embargo, la palabra executable estará en los programas ejecutables y, por lo general, también aparecerá la arquitectura.

Compara lo anterior con lo que obtengo en mi caja de Linux:

$ file /bin/ls
/bin/ls: ELF 64-bit LSB executable, AMD x86-64, version 1 (SYSV), for GNU/Linux 2.6.9, dynamically linked (uses shared libs), stripped

Y una caja Solaris:

$ file /bin/ls
/bin/ls: ELF 32-bit MSB executable SPARC Version 1, dynamically linked, stripped

En los tres, verá la palabra executable y la arquitectura ( x86-64 , i386 o SPARC con 32-bit ).

Apéndice

Muchas gracias, ese parece ser el camino a seguir. Antes de marcar esto como mi respuesta, ¿puede por favor guiarme a qué tipo de script shell shell debería realizar (es decir, qué tipo de análisis) en "archivo" para verificar si puedo ejecutar un programa? Si tal prueba es demasiado difícil de hacer en general, al menos me gustaría verificar si es un ejecutable de Linux o OSX (Mach-O)

Desde lo alto de mi cabeza, podrías hacer algo como esto en BASH:

if [ -x "$file" ] && file "$file" | grep -q "Mach-O"
then
echo "This is an executable Mac file"
elif [ -x "$file" ] && file "$file" | grep -q "GNU/Linux"
then
echo "This is an executable Linux File"
elif [ -x "$file" ] && file "$file" | grep q "shell script"
then
echo "This is an executable Shell Script"
elif [ -x "$file" ]
then
echo "This file is merely marked executable, but what type is a mystery"
else
echo "This file isn''t even marked as being executable"
fi

Básicamente, estoy ejecutando la prueba, luego, si eso tiene éxito, hago un grep en la salida del comando de file . El grep -q significa no imprimir ninguna salida, pero use el código de salida de grep para ver si encontré la cadena. Si su sistema no toma grep -q , puede probar grep "regex" > /dev/null 2>&1 .

Nuevamente, la salida del comando de file puede variar de un sistema a otro, por lo que tendrá que verificar que funcionen en su sistema. Además, estoy comprobando el bit ejecutable. Si un archivo es un ejecutable binario, pero el bit ejecutable no está activado, diré que no es ejecutable. Esto puede no ser lo que quieres.

Answer 3

Parece que nadie notó que el operador -x no difiere el archivo con el directorio.

Entonces, para verificar con precisión un archivo ejecutable, puede usar [[ -f SomeFile && -x SomeFile ]]

Answer 4

También parece que nadie advirtió -x operador en enlaces simbólicos. Un enlace simbólico (cadena) a un archivo regular (no clasificado como ejecutable) falla la prueba.