#!/bin/bash
# hacer-pkg-minimo: arma los paquetes de summapack SIN las herramientas de
# empaquetado de la distribucion (sin dpkg-dev, debhelper, fakeroot ni
# autotools) y, con --instalar, los instala. Es el ultimo recurso: una
# maquina sin red y sin esas herramientas, que por eso no puede ni fabricarlas
# ni bajarlas (ver sp, la autoinstalacion desde el arbol).
#
#   hacer-pkg-minimo [--instalar] [--raiz R] [--prueba] [--forma F]
#                    [--desde-tgz A.tgz] [--salida D] [DIR]
#
#   --instalar  instalar el paquete recien armado (dpkg, rpm o instalar-tgz)
#   --raiz R    instalar en R en lugar de / (una imagen, una jaula, o para
#               probar sin ser root)
#   --prueba    decir que haria, sin armar ni instalar
#   --forma F   armar solo deb, rpm, tgz o directo; por omision, los tres
#   --desde-tgz A  armar desde un .tgz ya hecho, sin arbol de fuentes
#   --salida D  adonde van los paquetes armados (por omision, DIR)
#   DIR         el arbol de summapack (por omision, el de este script)
#
# SIN ARBOL: --desde-tgz A.tgz. El .tgz es el arbol de archivos del paquete
# ya armado, asi que de ahi salen igual el .deb y el .rpm, sin fuentes y sin
# herramientas: se desempaqueta, se le pone el DEBIAN/ o la cabecera de rpm, y
# se instala con el gestor de la maquina. Si no hay ni dpkg ni rpm se instala
# el propio .tgz con instalar-tgz, derecho. El nombre del archivo dice el
# resto: NOMBRE_VERSION_ARQ.tgz. Los datos del paquete (resumen, responsable,
# licencia) salen del summapack.summa que viaja adentro, en
# usr/share/summapack/data. Es el caso del sp suelto, que lleva el tgz adentro
# como datos: ver bin/sp-bootstrap.in. Pedido del autor, 02/11/2026.
#
# Arma LOS TRES PAQUETES --deb, rpm y tgz--, como hacer-pkg, y A MANO, sin
# ninguna de las herramientas de construccion de la distribucion: no hace
# falta dpkg-dev, debhelper ni fakeroot para el .deb, ni rpmbuild para el .rpm:
#   deb      ar y tar escritos aca (si esta dpkg-deb se usa, que es exacto)
#   rpm      cabecera y cpio escritos aca (armar-rpm.sh)
#   tgz      tar y gzip
# De los tres se instala el que entienda el gestor de esta maquina, que es lo
# que siempre esta aunque no esten las herramientas de construccion:
#   con dpkg o apt       el .deb (dpkg -i)
#   con rpm              el .rpm (rpm -U --nodeps)
#   sin ninguno de ellos el .tgz, con instalar-tgz, que lleva el registro de
#                        lo que puso para poder sacarlo con --quitar
#   sin descompresores   no se puede armar ningun paquete: queda directo, que
#                        pone los archivos en su lugar, que es lo que hace
#                        make install, anotados en el mismo registro. Hace
#                        falta porque el make install del arbol necesita
#                        autotools, que en este caso es justo lo que no hay.
#
# Salen los paquetes de los DOS componentes de summapack --el propiamente
# dicho y la biblioteca mem_util, que sale partida en dos--, los mismos tres
# que arma hacer-pkg:
#   summapack                 independiente de arquitectura (all/noarch): los
#                             archivos que el .summa manda instalar, que son
#                             todos guiones y datos
#   libmem-util0              la biblioteca C mem_util compartida
#   libmem-util-dev           sus encabezados, el .a y el mem_util.pc
# mem_util se compila A MANO con el compilador que haya, sin autotools: las
# seis fuentes de mem_util/src, el .so con el soname libmem_util.so.0, el .a
# con ar, y el mem_util.pc que normalmente genera configure, en el libdir que
# corresponda a la distribucion (gcc -print-multiarch, o lib64). Si no hay
# compilador se avisa y siguen los de summapack solo, que es lo que importa
# para arrancar; los proyectos que usen la biblioteca la van a pedir despues.
# Son tres paquetes en tres formatos: nueve archivos de una corrida, o tres si
# no hay compilador.
#
# La version lleva ~minimo, que para dpkg es ANTERIOR a la normal, de modo que
# el paquete completo lo actualiza en cuanto haya herramientas.
#
# Solo usa lo que trae cualquier sistema: bash, coreutils, tar y gzip (y
# el compilador si esta, para mem_util). Pedido del
# autor, 02/11/2026. Todo el recorrido esta contado en
# doc/instalar-sin-red-ni-herramientas.md.
set -euo pipefail

PROGRAMA=${0##*/}
instalar=0
prueba=0
raiz=/
arbol=
forma=
desde_tgz=
salida=

while (($#)); do
    case $1 in
        --instalar) instalar=1; shift ;;
        --prueba)   prueba=1; shift ;;
        --raiz)     (($# >= 2)) || { echo "$PROGRAMA: falta R despues de --raiz" >&2; exit 2; }
                    raiz=$2; shift 2 ;;
        --forma)    (($# >= 2)) || { echo "$PROGRAMA: falta F despues de --forma" >&2; exit 2; }
                    forma=$2; shift 2 ;;
        --desde-tgz) (($# >= 2)) || { echo "$PROGRAMA: falta A despues de --desde-tgz" >&2; exit 2; }
                    desde_tgz=$2; shift 2 ;;
        --salida)   (($# >= 2)) || { echo "$PROGRAMA: falta D despues de --salida" >&2; exit 2; }
                    salida=$2; shift 2 ;;
        -h|--help)  sed -n '2,71s/^# \{0,1\}//p' "$0"; exit 0 ;;
        -*)         echo "$PROGRAMA: no conozco $1 (--help)" >&2; exit 2 ;;
        *)          arbol=$1; shift ;;
    esac
done

hay() { command -v "$1" >/dev/null 2>&1; }

aqui=$(cd -- "$(dirname -- "$0")" && pwd)

if [[ -n $desde_tgz ]]; then
    # Sin arbol: el paquete sale de un .tgz ya hecho. Es el caso del sp
    # suelto, que lleva el tgz adentro: de ahi se arma el deb o el rpm, o se
    # instala el tgz derecho. El nombre dice todo: NOMBRE_VERSION_ARQ.tgz.
    [[ -f $desde_tgz ]] || { echo "$PROGRAMA: no encuentro $desde_tgz" >&2; exit 1; }
    hay tar && hay gzip || {
        echo "$PROGRAMA: para leer el tgz hacen falta tar y gzip" >&2; exit 1
    }
    desde_tgz=$(cd -- "$(dirname -- "$desde_tgz")" && pwd)/$(basename -- "$desde_tgz")
    arbol=$(dirname -- "$desde_tgz")        # los paquetes nuevos van al lado
    base=$(basename -- "$desde_tgz" .tgz)
    tgz_arq=${base##*_}; resto=${base%_*}
    tgz_version=${resto##*_}; tgz_nombre=${resto%_*}
    [[ $base == *_*_* && -n $tgz_nombre && -n $tgz_version && -n $tgz_arq ]] || {
        echo "$PROGRAMA: el tgz tiene que llamarse NOMBRE_VERSION_ARQ.tgz" >&2; exit 2
    }
    # EL ~minimo TAMBIEN ACA, aunque el tgz sea el estandar: el deb y el rpm
    # que salen de aca traen los mismos archivos pero NO declaran dependencias
    # --no pueden, porque existen para arrancar una maquina donde no se puede
    # bajar nada--, asi que no son el paquete de la distribucion. Sin la marca,
    # el gestor veria instalada la version estandar y el paquete completo, que
    # si declara sus dependencias, no lo actualizaria nunca. El tgz no se toca:
    # ese se instala con su propia version, que es la estandar.
    version=$tgz_version
    [[ $version == *'~minimo' ]] || version=$version~minimo
else
    [[ -n $arbol ]] || arbol=$(cd -- "$aqui/.." && pwd)
    arbol=$(cd -- "$arbol" && pwd)
    [[ -f $arbol/summapack.summa ]] || {
        echo "$PROGRAMA: no encuentro $arbol/summapack.summa" >&2; exit 1
    }

    # los datos del paquete salen del .summa, que es shell
    # shellcheck source=/dev/null
    . "$arbol/summapack.summa"

    # la version del arbol si se la puede saber; si no, la del .summa
    version=$BASEVERSION-1
    if [[ -x $arbol/bin/sp-version ]]; then
        v=$("$arbol/bin/sp-version" "$arbol" 2>/dev/null) || v=
        [[ -z $v ]] || version=$v
    fi
    version=$version~minimo
fi

# los paquetes armados van a --salida; por omision al arbol, o al lado del
# tgz cuando se arma desde un tgz
[[ -n $salida ]] || salida=$arbol
[[ -d $salida ]] || { echo "$PROGRAMA: no existe el directorio $salida" >&2; exit 1; }
salida=$(cd -- "$salida" && pwd)

# la arquitectura de lo compilado, como la nombra cada gestor
if hay dpkg; then arq_deb=$(dpkg --print-architecture 2>/dev/null) || arq_deb=; fi
[[ -n ${arq_deb:-} ]] || arq_deb=$(uname -m)
arq_rpm=$(uname -m)

# el nombre que le toca a cada paquete: archivo_de FORMA NOMBRE ARQ. Cada
# gestor nombra distinto la misma arquitectura: amd64 en dpkg, x86_64 en rpm.
archivo_de() {
    local suya=$arq_rpm
    [[ $3 != all ]] || suya=noarch
    case $1 in
        deb) echo "$salida/$2_${version}_$3.deb" ;;
        rpm) echo "$salida/$2-${version}.$suya.rpm" ;;  # nombre-version-release.arq
        tgz) echo "$salida/$2_${version}_$3.tgz" ;;
    esac
}

# Se arman los tres paquetes --deb, rpm y tgz--, como hace hacer-pkg: el
# paquete que sirve en esta maquina y los que sirven en las otras, que para
# eso estan los formatos. Con --forma se arma uno solo. Si no hay con que
# comprimir no se puede armar ninguno y queda directo, que pone los archivos
# en su lugar. Pedido del autor, 02/11/2026.
if [[ -n $forma ]]; then
    case $forma in
        tgz) [[ -z $desde_tgz ]] || {
                 echo "$PROGRAMA: con --desde-tgz el tgz ya esta: $desde_tgz" >&2; exit 2
             }
             formas=(tgz) ;;
        deb|rpm|directo) formas=("$forma") ;;
        *) echo "$PROGRAMA: forma desconocida: $forma (deb, rpm, tgz, directo)" >&2; exit 2 ;;
    esac
elif [[ -n $desde_tgz ]]; then
    formas=(deb rpm)       # el tgz ya esta: el que se arma es el nativo
elif hay gzip; then
    formas=(deb rpm tgz)
else
    formas=(directo)
    echo "$PROGRAMA: sin gzip no se puede armar ningun paquete; van los archivos directo" >&2
fi

# cual se instala: el del gestor que tenga la maquina
if hay dpkg;   then instalar_forma=deb
elif hay rpm;  then instalar_forma=rpm
elif hay gzip; then instalar_forma=tgz
else                instalar_forma=directo
fi
for f in "${formas[@]}"; do [[ $f == "$instalar_forma" ]] && break; done
if [[ $f != "$instalar_forma" ]]; then
    # con --desde-tgz el tgz no se arma porque ya esta, pero se puede instalar
    if [[ -n $desde_tgz && $instalar_forma == tgz ]]; then
        :
    else
        # se pidio --forma X y se instala X, aunque no sea la del gestor
        instalar_forma=${formas[0]}
    fi
fi
if [[ $instalar_forma == directo ]] && ((!instalar)) && [[ ${#formas[@]} == 1 ]]; then
    echo "$PROGRAMA: la forma directo no arma un archivo: pide --instalar" >&2
    exit 2
fi

if [[ -n $desde_tgz ]]; then
    echo "$PROGRAMA: $tgz_nombre $version $tgz_arq, formas ${formas[*]}, desde $desde_tgz"
else
    echo "$PROGRAMA: summapack $version, formas ${formas[*]}, desde $arbol"
fi
if ((prueba)); then
    for f in "${formas[@]}"; do
        [[ $f == directo ]] && continue
        if [[ -n $desde_tgz ]]; then
            echo "  [prueba] armaria $(archivo_de "$f" "$tgz_nombre" "$tgz_arq")"
            continue
        fi
        echo "  [prueba] armaria $(archivo_de "$f" summapack all)"
        if hay gcc || hay cc; then
            echo "  [prueba] armaria $(archivo_de "$f" libmem-util0 "$arq_deb")"
            echo "  [prueba] armaria $(archivo_de "$f" libmem-util-dev "$arq_deb")"
        else
            echo "  [prueba] sin compilador: no armaria libmem-util0 ni libmem-util-dev"
        fi
    done
    ((instalar)) && echo "  [prueba] y en $raiz instalaria el $instalar_forma"
    exit 0
fi

etapa=$(mktemp -d "${TMPDIR:-/tmp}/summapack-minimo.XXXXXX")
trap 'rm -rf -- "$etapa"' EXIT
pkg=$etapa/pkg

salteados=0
if [[ -n $desde_tgz ]]; then
    # Sin arbol: el contenido ya esta armado adentro del tgz, que es
    # justamente el arbol de archivos del paquete. Se desempaqueta y de ahi
    # salen el deb o el rpm, sin tocar nada mas.
    mkdir -p -- "$pkg"
    tar -C "$pkg" -xzf "$desde_tgz"
    # el registro de instalar-tgz, si el tgz ya se instalo alguna vez, no es
    # parte del paquete
    rm -rf -- "$pkg/var/lib/summapack/tgz"
    [[ -d $pkg/var/lib/summapack ]] && rmdir -p --ignore-fail-on-non-empty -- \
        "$pkg/var/lib/summapack" 2>/dev/null
    # los datos del paquete, si viajan adentro (desde el 02/11/2026 van en
    # usr/share/summapack/data). Sin ellos quedan los minimos de aca.
    adentro=$pkg/usr/share/summapack/data/summapack.summa
    if [[ -f $adentro ]]; then
        # shellcheck source=/dev/null
        . "$adentro"
    else
        echo "$PROGRAMA: el tgz no trae summapack.summa: los datos del paquete salen minimos" >&2
    fi
    : "${SUMMARY:=Summapack, la base comun de los paquetes de Simusol y Siru}"
    : "${MAINTAINER:=SummaPack <dsa@unsa.edu.ar>}"
fi

# los archivos, del mismo listado que usan el make install y el paquete normal
# (ARCHIVO_summapack_install del .summa): ORIGEN DESTINO [NOMBRE]
while [[ -z $desde_tgz ]] && read -r origen destino nombre; do
    [[ -n ${origen:-} ]] || continue
    case $origen in '#'*|'!'*) continue ;; esac
    [[ -n ${destino:-} ]] || { echo "$PROGRAMA: sin destino: $origen" >&2; exit 1; }
    mkdir -p -- "$pkg/$destino"
    if [[ -n ${nombre:-} ]]; then
        [[ -e $arbol/$origen ]] || { echo "$PROGRAMA: falta $origen (salteado)" >&2; salteados=1; continue; }
        cp -a -- "$arbol/$origen" "$pkg/$destino/$nombre"
    else
        hubo=0
        for f in $arbol/$origen; do
            [[ -e $f ]] || continue
            cp -a -- "$f" "$pkg/$destino/"
            hubo=1
        done
        ((hubo)) || { echo "$PROGRAMA: falta $origen (salteado)" >&2; salteados=1; }
    fi
done <<< "${ARCHIVO_summapack_install:-}"

# De aca en adelante se prepara el contenido, que con --desde-tgz ya viene
# preparado adentro del tgz: no se toca.
if [[ -z $desde_tgz ]]; then

# los archivos salen del arbol de trabajo, no de un svn export como el paquete
# normal, asi que puede haber venido pegado lo generado o lo que no esta
# versionado: no viaja en el paquete.
if [[ -d $pkg ]]; then
    find "$pkg" -depth \( -name __pycache__ -o -name .svn \) -type d -exec rm -rf -- {} +
    find "$pkg" \( -name '*.pyc' -o -name '*~' -o -name '*.orig' -o -name '*.rej' \) \
        -type f -delete
fi

# que los programas queden ejecutables y nada quede del usuario que armo
[[ -d $pkg/usr/bin ]] && find "$pkg/usr/bin" -type f -exec chmod 755 -- {} +
find "$pkg" -type d -exec chmod 755 -- {} +

# el copyright que pide la politica de Debian (debhelper lo genera del
# debian/copyright; aca sale del .summa y remite al COPYING que va adentro)
if [[ -d $pkg/usr/share/doc/summapack ]]; then
    {
        echo "Upstream-Name: summapack"
        [[ -z ${HOMEPAGE:-} ]] || echo "Source: $HOMEPAGE"
        echo
        echo "Files: *"
        echo "Copyright: $AUTHOR"
        echo "License: ${LICENSE:-GPL-3+}"
        echo " El texto completo esta en /usr/share/doc/summapack/COPYING.gz"
    } > "$pkg/usr/share/doc/summapack/copyright"
fi

# comprimir lo mismo que comprime debhelper: manuales, info, y lo de doc que
# pase de 4k (menos el copyright, que la politica quiere sin comprimir)
for d in usr/share/man usr/share/info; do
    [[ -d $pkg/$d ]] && find "$pkg/$d" -type f ! -name '*.gz' -exec gzip -9n -- {} +
done
if [[ -d $pkg/usr/share/doc/summapack ]]; then
    # la historia de Debian, como la pone dh_installchangelogs
    [[ -f $arbol/debian/changelog ]] &&
        cp -a -- "$arbol/debian/changelog" "$pkg/usr/share/doc/summapack/changelog.Debian"
    # los changelog van comprimidos siempre, no solo si pasan de 4k
    find "$pkg/usr/share/doc" -type f ! -name '*.gz' ! -name copyright \
        \( -size +4k -o -name 'changelog*' \) -exec gzip -9n -- {} +
fi

fi   # fin de la preparacion del contenido (no va con --desde-tgz)

# mem_util, la biblioteca C de summapack: el paquete normal la compila con
# autotools, porque es un subproyecto (mem_util/configure.ac). Aca no hay
# autotools, asi que se compila a mano con el compilador que haya: las seis
# fuentes, el .so con su soname, el .a y el mem_util.pc que normalmente genera
# configure. Si no hay compilador se avisa y se sigue con summapack solo, que
# es lo que importa para arrancar. Pedido del autor, 02/11/2026.
pkg_lib=$etapa/pkg-lib
pkg_dev=$etapa/pkg-dev
hay_mem_util=0
FUENTES_MEM_UTIL=(util mem time datetime abs2rel rel2abs)
ENCABEZADOS_MEM_UTIL=(util.h mem.h time_mem.h pathconv.h)

compilar_mem_util() {
    local cc fuentes=$arbol/mem_util/src obj=$etapa/memutil c libdir multi vers
    if [[ -n ${CC:-} ]] && hay "$CC"; then cc=$CC
    elif hay gcc; then cc=gcc
    elif hay cc;  then cc=cc
    else return 2
    fi
    [[ -d $fuentes ]] || { echo "$PROGRAMA: no encuentro $fuentes" >&2; return 1; }
    hay ar || { echo "$PROGRAMA: sin ar no se arma libmem_util.a" >&2; return 1; }
    mkdir -p -- "$obj"
    for c in "${FUENTES_MEM_UTIL[@]}"; do
        "$cc" -O2 -fPIC -I"$fuentes" -c "$fuentes/$c.c" -o "$obj/$c.o" || return 1
    done
    # el soname y los tres nombres son los que deja libtool con version-info 0
    "$cc" -shared -Wl,-soname,libmem_util.so.0 \
        -o "$obj/libmem_util.so.0.0.0" "$obj"/*.o -lm || return 1
    ar rcs "$obj/libmem_util.a" "$obj"/*.o || return 1
    # adonde van las bibliotecas en esta distribucion
    multi=$("$cc" -print-multiarch 2>/dev/null) || multi=
    if [[ -n $multi ]]; then libdir=/usr/lib/$multi
    elif [[ -d /usr/lib64 && $(uname -m) == *64 ]]; then libdir=/usr/lib64
    else libdir=/usr/lib
    fi
    mkdir -p -- "$pkg_lib$libdir" "$pkg_dev$libdir/pkgconfig" "$pkg_dev/usr/include"
    cp -a -- "$obj/libmem_util.so.0.0.0" "$pkg_lib$libdir/"
    ln -s libmem_util.so.0.0.0 "$pkg_lib$libdir/libmem_util.so.0"
    ln -s libmem_util.so.0.0.0 "$pkg_dev$libdir/libmem_util.so"
    cp -a -- "$obj/libmem_util.a" "$pkg_dev$libdir/"
    for c in "${ENCABEZADOS_MEM_UTIL[@]}"; do
        cp -a -- "$fuentes/$c" "$pkg_dev/usr/include/" || return 1
    done
    vers=$(sed -n 's/^AC_INIT(\[mem_util\], *\[\([^]]*\)\].*/\1/p' \
        "$arbol/mem_util/configure.ac" 2>/dev/null) || vers=
    [[ -n $vers ]] || vers=1.0
    sed -e 's|@prefix@|/usr|' -e 's|@exec_prefix@|/usr|' \
        -e "s|@libdir@|$libdir|" -e 's|@includedir@|/usr/include|' \
        -e "s|@PACKAGE_VERSION@|$vers|" \
        "$arbol/mem_util/mem_util.pc.in" > "$pkg_dev$libdir/pkgconfig/mem_util.pc" || return 1
    # la documentacion que el .summa le pone a libmem-util0
    mkdir -p -- "$pkg_lib/usr/share/doc/libmem-util0"
    for c in README NEWS HACKING; do
        [[ -f $arbol/mem_util/$c ]] &&
            cp -a -- "$arbol/mem_util/$c" "$pkg_lib/usr/share/doc/libmem-util0/"
    done
    find "$pkg_lib" "$pkg_dev" -type d -exec chmod 755 -- {} +
    return 0
}

if [[ -n $desde_tgz ]]; then
    # sin arbol no hay fuentes que compilar: el paquete es el que trae el tgz
    :
elif compilar_mem_util; then
    hay_mem_util=1
    echo "$PROGRAMA: mem_util compilada a mano: van libmem-util0 y libmem-util-dev"
elif (($? == 2)); then
    echo "$PROGRAMA: sin compilador no se arman libmem-util0 ni libmem-util-dev; sigue summapack solo" >&2
else
    echo "$PROGRAMA: no se pudo compilar mem_util; sigue summapack solo" >&2
fi

# el .deb escrito a mano: un archivo ar con debian-binary, control.tar.gz y
# data.tar.gz, en ese orden. El ar se escribe aca (su cabecera son 60 bytes de
# texto) para no depender ni de binutils; si esta dpkg-deb se usa ese, que es
# el exacto. El formato es el 2.0, el que dpkg lee desde 1999.
armar_deb_a_mano() {
    local salida=$1 donde=$2 ar=$etapa/ar.$$ m t
    rm -rf -- "$ar"; mkdir -p -- "$ar"
    printf '2.0\n' > "$ar/debian-binary"
    tar -C "$donde/DEBIAN" --owner=0 --group=0 --numeric-owner -czf "$ar/control.tar.gz" .
    tar -C "$donde" --exclude=./DEBIAN --owner=0 --group=0 --numeric-owner -czf "$ar/data.tar.gz" .
    printf '!<arch>\n' > "$salida"
    for m in debian-binary control.tar.gz data.tar.gz; do
        t=$(stat -c %s -- "$ar/$m")
        # nombre(16) fecha(12) uid(6) gid(6) modo(8) tamanio(10) fin(2)
        printf '%-16s%-12u%-6u%-6u%-8s%-10u`\n' "$m" 0 0 0 100644 "$t" >> "$salida"
        cat -- "$ar/$m" >> "$salida"
        ((t % 2 == 0)) || printf '\n' >> "$salida"   # los miembros van parejos
    done
}

descripcion=(
    "Armado a mano, sin las herramientas de construccion de la"
    "distribucion, para una maquina sin red y sin esas herramientas. Trae"
    "los mismos archivos que el paquete normal, pero no exige ninguna"
    "dependencia: existe para arrancar una maquina donde no se puede bajar"
    "nada. La biblioteca C mem_util (libmem-util0, libmem-util-dev) viaja"
    "solo si habia un compilador donde se armo. La version lleva ~minimo,"
    "anterior a la normal, para que el paquete completo lo actualice en"
    "cuanto haya con que fabricarlo."
)

# armar_deb SALIDA DIR NOMBRE ARQ RESUMEN RECOMIENDA
armar_deb() {
    local salida=$1 donde=$2 nombre=$3 arq=$4 resumen=$5 recomienda=$6 tamanio
    mkdir -p -- "$donde/DEBIAN"
    # Lo que ocupa instalado, en kB, como lo cuenta dpkg-gencontrol: cada
    # archivo redondeado al kB de arriba, mas un kB por directorio, sin el
    # DEBIAN/. (du -ks cuenta bloques de 4k y da casi un 30% de mas: 832
    # contra los 647 que declara el paquete normal; asi da 643, que es el
    # mismo numero salvo 4 kB.)
    tamanio=$( { find "$donde" -path "$donde/DEBIAN" -prune -o -type f -printf '%s\n'
                 find "$donde" -path "$donde/DEBIAN" -prune -o -mindepth 1 -type d \
                     -printf '1024\n'; } 2>/dev/null |
               awk '{ t += int(($1 + 1023) / 1024) } END { print t + 0 }') || tamanio=
    {
        echo "Package: $nombre"
        echo "Version: $version"
        echo "Architecture: $arq"
        echo "Maintainer: $MAINTAINER"
        [[ -z ${tamanio:-} ]] || echo "Installed-Size: $tamanio"
        echo "Section: ${SECTION:-devel}"
        echo "Priority: ${PRIORITY:-optional}"
        [[ -z ${HOMEPAGE:-} ]] || echo "Homepage: $HOMEPAGE"
        # sin Depends a proposito: estos paquetes existen para arrancar una
        # maquina donde no se puede bajar nada, asi que no pueden exigir nada.
        [[ -z $recomienda ]] || echo "Recommends: $recomienda"
        echo "Description: $resumen (paquete minimo)"
        printf ' %s\n' "${descripcion[@]}"
    } > "$donde/DEBIAN/control"
    if hay md5sum; then
        (cd -- "$donde" && find . -path ./DEBIAN -prune -o -type f -print0 \
            | xargs -0 -r md5sum | sed 's#  \./#  #' > DEBIAN/md5sums)
    fi
    if hay dpkg-deb; then
        dpkg-deb --root-owner-group --build "$donde" "$salida" \
            || dpkg-deb --build "$donde" "$salida"
    else
        echo "$PROGRAMA: sin dpkg-deb: el .deb se escribe a mano"
        armar_deb_a_mano "$salida" "$donde"
    fi
}

# armar_rpm SALIDA DIR NOMBRE ARQ RESUMEN
armar_rpm() {
    local salida=$1 donde=$2 nombre=$3 arq=$4 resumen=$5
    local armador=$arbol/share/summapack/data/armar-rpm.sh
    [[ -f $armador ]] || armador=$pkg/usr/share/summapack/data/armar-rpm.sh
    [[ -f $armador ]] || armador=/usr/share/summapack/data/armar-rpm.sh
    [[ -f $armador ]] || { echo "$PROGRAMA: falta armar-rpm.sh (de summapack)" >&2; return 1; }
    sh "$armador" --raiz-archivos "$donde" --salida "$salida" --excluir DEBIAN \
        --nombre "$nombre" --version "${version%-*}" --release "${version##*-}" \
        --arch "$arq" --summary "$resumen (paquete minimo)" \
        --licencia "${LICENSE:-GPL-3+}" --grupo "${SECTION:-devel}" \
        --url "${HOMEPAGE:-}" --empaquetador "$MAINTAINER" \
        --descripcion "$(printf '%s\n' "${descripcion[@]}")"
}

# los paquetes que hay para armar: NOMBRE ARQ DIRECTORIO RESUMEN | RECOMIENDA
if [[ -n $desde_tgz ]]; then
    componentes=("$tgz_nombre|$tgz_arq|$pkg|$SUMMARY|")
else
componentes=("summapack|all|$pkg|$SUMMARY|libmem-util-dev, rsync, openssh-client, python3")
if ((hay_mem_util)); then
    componentes+=("libmem-util0|$arq_deb|$pkg_lib|${libmem_util0_SUMMARY:-utilidades de base de Siru}|")
    componentes+=("libmem-util-dev|$arq_deb|$pkg_dev|${libmem_util_dev_SUMMARY:-utilidades de base de Siru (archivos de desarrollo)}|libmem-util0")
fi
fi

# cada paquete en cada forma; el DEBIAN/ que necesita el .deb no entra en los
# otros dos (el tgz lo excluye y armar-rpm.sh lo saca con --excluir)
armados=()
for f in "${formas[@]}"; do
    [[ $f == directo ]] && continue
    for c in "${componentes[@]}"; do
        IFS='|' read -r c_nombre c_arq c_dir c_resumen c_recom <<< "$c"
        archivo=$(archivo_de "$f" "$c_nombre" "$c_arq")
        case $f in
            deb) armar_deb "$archivo" "$c_dir" "$c_nombre" "$c_arq" "$c_resumen" "$c_recom" ;;
            rpm) armar_rpm "$archivo" "$c_dir" "$c_nombre" \
                     "$([[ $c_arq == all ]] && echo noarch || echo "$arq_rpm")" "$c_resumen" ;;
            tgz) tar -C "$c_dir" --exclude=./DEBIAN --owner=0 --group=0 --numeric-owner \
                     -czf "$archivo" . ;;
        esac
        echo "$PROGRAMA: armado $archivo"
        armados+=("$archivo")
    done
done
((salteados)) && echo "$PROGRAMA: ojo, faltaban archivos del listado (arriba)" >&2

if ((instalar)); then
    # se instalan los de la forma que entiende el gestor de esta maquina; los
    # de las otras dos formas quedan armados, para las maquinas donde sirven
    echo "$PROGRAMA: de los armados se instalan los $instalar_forma"
    paquetes=()
    if [[ -n $desde_tgz && $instalar_forma == tgz ]]; then
        # el tgz que vino: se instala derecho, sin armar nada
        paquetes=("$desde_tgz")
    elif [[ $instalar_forma != directo ]]; then
        for c in "${componentes[@]}"; do
            IFS='|' read -r c_nombre c_arq c_dir c_resumen c_recom <<< "$c"
            paquetes+=("$(archivo_de "$instalar_forma" "$c_nombre" "$c_arq")")
        done
    fi
    case $instalar_forma in
        deb) orden=(dpkg -i -- "${paquetes[@]}")
             [[ $raiz == / ]] || orden=(dpkg --root="$raiz" -i -- "${paquetes[@]}") ;;
        rpm) orden=(rpm -U --nodeps -vh "${paquetes[@]}")
             [[ $raiz == / ]] || orden=(rpm --root="$raiz" -U --nodeps -vh "${paquetes[@]}") ;;
        tgz) poner=$arbol/bin/instalar-tgz
             # sin arbol, el que viaja adentro del paquete, o el instalado
             [[ -x $poner ]] || poner=$pkg/usr/bin/instalar-tgz
             [[ -x $poner ]] || poner=$aqui/instalar-tgz
             [[ -x $poner ]] || poner=/usr/bin/instalar-tgz
             [[ -x $poner ]] || { echo "$PROGRAMA: no encuentro instalar-tgz" >&2; exit 1; }
             orden=("$poner" "${paquetes[@]}")
             [[ $raiz == / ]] || orden=("$poner" --raiz "$raiz" "${paquetes[@]}") ;;
        directo)
             # los archivos en su lugar, como make install, con el registro de
             # instalar-tgz adentro para poder sacarlos con --quitar. Lo de
             # mem_util, si se compilo, va en el mismo registro.
             for c in "${componentes[@]}"; do
                 IFS='|' read -r c_nombre c_arq c_dir c_resumen c_recom <<< "$c"
                 [[ $c_dir == "$pkg" ]] || cp -a -- "$c_dir/." "$pkg/"
             done
             reg=$pkg/var/lib/summapack/tgz
             mkdir -p -- "$reg"
             (cd -- "$pkg" && find . \( -type f -o -type l \) \
                 -not -path './var/lib/summapack/tgz/*' | sed 's#^\./##' \
                 | LC_ALL=C sort) > "$reg/summapack.lista"
             printf '%s\n' "$version" > "$reg/summapack.version"
             orden=(cp -a -- "$pkg/." "$raiz/") ;;
    esac
    # root solo si hace falta. dpkg y rpm lo piden siempre, incluso con --root
    # en un directorio propio, porque llevan su propia base de datos; poner los
    # archivos (tgz o directo) alcanza con que la raiz sea escribible.
    if ((EUID != 0)); then
        case $instalar_forma in
            deb|rpm) orden=(sudo -- "${orden[@]}") ;;
            *)       [[ -w $raiz ]] || orden=(sudo -- "${orden[@]}") ;;
        esac
    fi
    echo "$PROGRAMA: instalando: ${orden[*]}"
    "${orden[@]}"
fi
