¿Cómo extraigo el contenido de un rpm?

Tengo un rpm y quiero tratarlo como un tarball. Quiero extraer el contenido en un directorio para poder inspeccionar el contenido. Estoy familiarizado con los comandos de consulta de un paquete desinstalado. No quiero simplemente una lista de los contenidos de las rpm. es decir

$ rpm -qpl foo.rpm

Quiero inspeccionar el contenido de varios archivos contenidos en las rpm. No quiero instalar las rpm. También estoy al tanto de la capacidad de rpms para hacer modificaciones adicionales en las secciones% post, y cómo verificarlas. es decir

$ rpm -qp --scripts foo.rpm

Sin embargo, en este caso eso no me preocupa.

¿ rpm2cpioProbaste el comando? Vea el siguiente ejemplo:

$ rpm2cpio php-5.1.4-1.esp1.x86_64.rpm | cpio -idmv

/etc/httpd/conf.d/php.conf  
./etc/php.d  
./etc/php.ini  
./usr/bin/php  
./usr/bin/php-cgi  
etc 

$ mkdir packagecontents; cd packagecontents
$ rpm2cpio ../foo.rpm | cpio -idmv
$ find . 

Para referencia: los argumentos de cpio son

-i = extract
-d = make directories
-m = preserve modification time
-v = verbose

Encontré la respuesta aquí: la respuesta de Lontar

Para aquellos que no tienen rpm2cpio, aquí está el antiguo script rpm2cpio.sh que extrae la carga de un paquete * .rpm.

Reubicado para la posteridad ... y la próxima generación.

Invocar así: ./rpm2cpio.sh .rpm | cpio -dimv

#!/bin/sh

pkg=$1
if [ "$pkg" = "" -o ! -e "$pkg" ]; then
    echo "no package supplied" 1>&2
    exit 1
fi

leadsize=96
o=`expr $leadsize + 8`
set `od -j $o -N 8 -t u1 $pkg`
il=`expr 256 \* \( 256 \* \( 256 \* $2 + $3 \) + $4 \) + $5`
dl=`expr 256 \* \( 256 \* \( 256 \* $6 + $7 \) + $8 \) + $9`
# echo "sig il: $il dl: $dl"

sigsize=`expr 8 + 16 \* $il + $dl`
o=`expr $o + $sigsize + \( 8 - \( $sigsize \% 8 \) \) \% 8 + 8`
set `od -j $o -N 8 -t u1 $pkg`
il=`expr 256 \* \( 256 \* \( 256 \* $2 + $3 \) + $4 \) + $5`
dl=`expr 256 \* \( 256 \* \( 256 \* $6 + $7 \) + $8 \) + $9`
# echo "hdr il: $il dl: $dl"

hdrsize=`expr 8 + 16 \* $il + $dl`
o=`expr $o + $hdrsize`
EXTRACTOR="dd if=$pkg ibs=$o skip=1"

COMPRESSION=`($EXTRACTOR |file -) 2>/dev/null`
if echo $COMPRESSION |grep -q gzip; then
        DECOMPRESSOR=gunzip
elif echo $COMPRESSION |grep -q bzip2; then
        DECOMPRESSOR=bunzip2
elif echo $COMPRESSION |grep -iq xz; then # xz and XZ safe
        DECOMPRESSOR=unxz
elif echo $COMPRESSION |grep -q cpio; then
        DECOMPRESSOR=cat
else
        # Most versions of file don't support LZMA, therefore we assume
        # anything not detected is LZMA
        DECOMPRESSOR=`which unlzma 2>/dev/null`
        case "$DECOMPRESSOR" in
            /* ) ;;
            *  ) DECOMPRESSOR=`which lzmash 2>/dev/null`
             case "$DECOMPRESSOR" in
                     /* ) DECOMPRESSOR="lzmash -d -c" ;;
                     *  ) DECOMPRESSOR=cat ;;
                 esac
                 ;;
        esac
fi

$EXTRACTOR 2>/dev/null | $DECOMPRESSOR

A veces puede encontrar un problema con el archivo RPM intermedio:

cpio: número con
formato incorrecto cpio: número con formato incorrecto
cpio: número con formato incorrecto
. . .
cpio: fin prematuro del archivo

Eso significa que podría estar empaquetado, en estos días es la compresión LZMA2 como de costumbre, por xz:

rpm2cpio <file>.rpm | xz -d | cpio -idmv

de lo contrario, podrías probar:

rpm2cpio <file>.rpm | lzma -d | cpio -idmv

La mayoría de las distribuciones han instalado la aplicación GUI file-roller que desempaqueta tar, zip, rpm y muchos más.

file-roller --extract-here package.rpm

Esto extraerá el contenido en el directorio actual.

7-zip comprende la mayoría de los tipos de archivos, incluidos rpm y el cpio incluido.

¡Simplemente puedes hacerlo tar -xvf <rpm file>también!

El poderoso administrador de archivos basado en texto mc (Midnight Commander, recordando vagamente al Norton Commander de los viejos tiempos de DOS) tiene la capacidad incorporada de inspeccionar y desempaquetar archivos .rpm y .rpms, solo "abre" el archivo .rpm (s) dentro de mc y seleccione CONTENTS.cpio: para un rpm obtiene acceso al árbol de instalación, para un rpms obtiene acceso al archivo .spec y todos los paquetes fuente.

Para depurar / inspeccionar sus rpm, sugiero usar redline, que es un programa de Java

Uso:

java -cp redline-1.2.1-jar-with-dependencies.jar org.redline_rpm.Scanner foo.rpm

Descargar: https://github.com/craigwblake/redline/releases

En NixOS, hay rpmextract. Es una envoltura alrededor de rpm2cpio, exactamente como quería @Alan Evangelista. https://github.com/NixOS/nixpkgs/tree/master/pkgs/tools/archivers/rpmextract

Al menos en OpenSuse, el unrpmcomando viene con el buildpaquete.

En un directorio adecuado (porque esta es una bomba de archivo):

unrpm file.rpm

Copie el archivo .rpm en una carpeta separada y luego ejecute el siguiente comando $ yourfile.rpm | cpio -idmv

La prueba de "DESCOMPRESIÓN" falla en CygWin, una de las plataformas más útiles para ello, debido a que la comprobación "grep" de "xz" distingue entre mayúsculas y minúsculas. El resultado de la comprobación "COMPRESIÓN:" es:

COMPRESSION='/dev/stdin: XZ compressed data'

Simplemente reemplazar 'grep -q' por 'grep -q -i' en todas partes parece resolver bien el problema.

He hecho algunas actualizaciones, particularmente agregando algunos comentarios y usando "caso" en lugar de "apiladas" declaraciones, e incluí esa solución a continuación

#!/bin/sh
#
# rpm2cpio.sh - extract 'cpio' contents of RPM
#
# Typical usage: rpm2cpio.sh rpmname | cpio -idmv
#

if [ "$# -ne 1" ]; then
    echo "Usage: $0 file.rpm" 1>&2
    exit 1
fi

rpm="$1"
if [ -e "$rpm" ]; then
    echo "Error: missing $rpm"
fi


leadsize=96
o=`expr $leadsize + 8`
set `od -j $o -N 8 -t u1 $rpm`
il=`expr 256 \* \( 256 \* \( 256 \* $2 + $3 \) + $4 \) + $5`
dl=`expr 256 \* \( 256 \* \( 256 \* $6 + $7 \) + $8 \) + $9`
# echo "sig il: $il dl: $dl"

sigsize=`expr 8 + 16 \* $il + $dl`
o=`expr $o + $sigsize + \( 8 - \( $sigsize \% 8 \) \) \% 8 + 8`
set `od -j $o -N 8 -t u1 $rpm`
il=`expr 256 \* \( 256 \* \( 256 \* $2 + $3 \) + $4 \) + $5`
dl=`expr 256 \* \( 256 \* \( 256 \* $6 + $7 \) + $8 \) + $9`
# echo "hdr il: $il dl: $dl"

hdrsize=`expr 8 + 16 \* $il + $dl`
o=`expr $o + $hdrsize`
EXTRACTOR="dd if=$rpm ibs=$o skip=1"

COMPRESSION=`($EXTRACTOR |file -) 2>/dev/null`
DECOMPRESSOR="cat"

case $COMPRESSION in
    *gzip*|*GZIP*)
        DECOMPRESSOR=gunzip
        ;;
    *bzip2*|*BZIP2*)
        DECOMPRESSOR=bunzip2
        ;;
    *xz*|*XZ*)
        DECOMPRESSOR=unxz
        ;;
    *cpio*|*cpio*)
        ;;
    *)
        # Most versions of file don't support LZMA, therefore we assume
        # anything not detected is LZMA
        DECOMPRESSOR="`which unlzma 2>/dev/null`"
        case "$DECOMPRESSOR" in
            /*)
                DECOMPRESSOR="$DECOMPRESSOR"
                ;;
            *)
                DECOMPRESSOR=`which lzmash 2>/dev/null`
                case "$DECOMPRESSOR" in
                    /* )
                        DECOMPRESSOR="lzmash -d -c"
                        ;;
                    *  )
                        echo "Warning: DECOMPRESSOR not found, assuming 'cat'" 1>&2
                        ;;
                esac
                ;;
        esac
esac

$EXTRACTOR 2>/dev/null | $DECOMPRESSOR

7-Zip es capaz de extraer el contenido. Funciona de la misma manera que funciona un archivo tar.gz. Un archivo comprimido dentro de un archivo comprimido.

En Windows 7 Pro con 7-Zip instalado:

Haga clic derecho en el archivo rpm. Pase el mouse sobre 7-Zip en el menú contextual. Seleccione extraer a "nombre de archivo".

Ingrese en la carpeta de nombre de archivo.

Haga clic derecho en el archivo cpio. Pase el mouse sobre 7-Zip en el menú contextual. Seleccione extraer a "nombre de archivo".

Estás listo. La carpeta con "nombre de archivo" contiene el contenido extraído para la inspección.

Sé que ustedes, chicos de Linux, desprecian que las cosas se hagan fáciles, pero a la larga, si tienen que pasar tiempo buscando una solución a un problema simple como este; esa ineficiencia te está costando dinero.

Dado que ustedes, chicos de Linux, desprecian la simplicidad eficiente, dudo mucho que la versión Linux de 7-Zip haga lo mismo exactamente de la misma manera.

¿Por qué hacerlo fácil cuando puedes hacer que sea estúpidamente difícil y pretender ser un genio al mismo tiempo?

Para ser claro; No soy un fanático de Windows. De hecho, estoy buscando mudarme a Linux. Simplemente no pude resistir la oportunidad de frotar lo que los desarrolladores de Windows verían en sus caras como sentido común, las mejores prácticas de desarrollador.

Solo alégrate de que sea yo quien publique esto y no tengas a Mark Harmon parado a tu lado; El agente especial Leroy Jethro Gibbs te habría dado una bofetada por no usar tu cabeza.

No sé qué regla de Gibbs es, pero la regla es: no te hagas las cosas más difíciles de lo que tienen que ser.

Ahora podemos ver quién necesita tomarse unas vacaciones. ¡Cuídate!